feat(state-layer): event-driven quota, seq freshness guards, and state layer stabilization

- Added HubStateStore targeted delta update methods (apply_delta_quota_updated, apply_delta_account_added, apply_delta_account_removed, apply_delta_route_changed)
- Added seq sequence freshness tracking in HubStateStore to drop stale out-of-order responses
- Added trigger_refresh_provider in HermesRefreshScheduler
- Bound multi-bucket quotas to specific model families (Claude vs Gemini) with truthful is_estimated tracking
- Connected OAuth completion to targeted account added events across all providers
- Pinned antigravity_provider package root to repo via __init__.py and added import invariant verification
- Added unit tests in tests/test_state_layer_and_event_driven_quota.py and tests/test_import_invariants.py
- Zero modifications to UI zone files (views, components, theme, wizard, hermes_hub_app.py)

agents/done/2026-08-21-A-antigravity-state-layer.md

@@ -0,0 +1,78 @@
+# Отчёт о выполнении: Задание A (Antigravity) — Слой состояния и данных
+
+## Дата
+2026-08-21
+
+## 1. Базовые Идентификаторы
+
+- **Стартовый `BASE_SHA`:** `f171a8069d97aef5d3a45f838daed63abf2e69c1`
+- **Ветка задачи:** `antigravity/state-layer`
+- **Финальный `FINAL_COMMIT_SHA`:** *(определяется после коммита)*
+- **Статус `origin/main`:** `f171a8069d97aef5d3a45f838daed63abf2e69c1`
+- **Тег `v0.1.1`:** **НЕ СОЗДАВАЛСЯ** (согласовано)
+- **Изоляция чужой зоны UI:** `git diff --name-only BASE_SHA..HEAD -- src/antigravity_provider/router/ui src/antigravity_provider/router/hermes_hub_app.py` → **ПУСТО** (0 файлов изменено в чужой зоне)
+
+---
+
+## 2. Выполненные Работы
+
+### P0. Публикация контракта ViewModel (`docs/UI_STATE_CONTRACT.md`)
+- Опубликован каноничный контракт `docs/UI_STATE_CONTRACT.md` до начала любых изменений в коде.
+- Содержит точные схемы `HubSnapshot`, `ProfileViewModel`, `QuotaSnapshot`, `QuotaBucket`, `SystemReadiness`, `AgentViewModel`, `RolePipeline`, `ProviderSummary`, каталог событий `EventBus` с payload, а также обязательный раздел **«Backend gaps»** с указанием реальных и baseline-данных по каждому провайдеру.
+
+### P0-bis. Устранение проблем импортов и изоляция пакета
+- Создан корневой `src/antigravity_provider/__init__.py`, делающий пакет стандартным (non-namespace), что устраняет смешивание установленной старой версии из `%LOCALAPPDATA%` с кодом репозитория.
+- Добавлен тест `test_antigravity_provider_loads_from_repo` в `tests/test_import_invariants.py`, гарантирующий загрузку пакета из `src/antigravity_provider`.
+
+### 1. Единый источник состояния (`HubSnapshot`)
+- `HubStateStore` выступает единственным источником состояния для UI.
+- UI-слой не инициирует `scan_all()`; данные поставляются готовым `HubSnapshot`.
+
+### 2. Централизованный планировщик обновлений (`HermesRefreshScheduler`)
+- В `HermesRefreshScheduler` реализованы гранулярные методы:
+  - `trigger_refresh_account(provider, profile_id)` — обновление одного аккаунта;
+  - `trigger_refresh_provider(provider)` — обновление аккаунтов выбранного провайдера;
+  - `trigger_refresh_all()` — полное обновление.
+- Защита от устаревших ответов: в `HubStateStore` и `HermesRefreshScheduler` используется `seq`-токен (`_latest_applied_seq`). Поздний/устаревший ответ отбрасывается без перезаписи свежего состояния.
+
+### 3. Событийная модель вместо полного пересбора
+- Реализованы точечные методы дельта-обновлений:
+  - `apply_delta_quota_updated`: отправляет `EVENT_QUOTA_UPDATED` с `{"provider", "profile_id", "snapshot"}` и атомарно обновляет snapshot.
+  - `apply_delta_account_added`: отправляет `EVENT_ACCOUNT_ADDED`.
+  - `apply_delta_account_removed`: отправляет `EVENT_ACCOUNT_REMOVED`.
+  - `apply_delta_route_changed`: отправляет `EVENT_ROUTING_UPDATED`.
+- OAuth-сессии (`profile_oauth.py`, `codex_oauth.py`, `grok_oauth.py`, `claude_oauth.py`) изолированы от общего планировщика. По завершении авторизации вызывается `apply_delta_account_added`, инициируя точечное обновление без глобального сканирования.
+
+### 4. Мульти-корзинные квоты и привязка к семействам моделей
+- В `account_identity.py` и `quota_collector.py`:
+  - Квоты Google Antigravity разделены на независимые пулы `antigravity.claude.5h`, `antigravity.claude.weekly` (`model_family="claude"`) и `antigravity.gemini.5h` (`model_family="gemini"`).
+  - При возникновении runtime 429 ошибки (`record_runtime_quota_error`) выставляется `source="runtime_event"`, `is_estimated=False`, исчерпывается конкретная корзина соответствующего семейства моделей, и посылается точечное событие `EVENT_QUOTA_UPDATED`.
+  - В baseline-режиме корзины честно помечены `source="baseline"`, `is_estimated=True`, percentages=`None`.
+
+### 5. Реестр моделей и интеграция дорожной карты
+- `CapabilityMatrix`, `UnifiedSkillRegistry` и `LifecycleSupervisor` интегрированы в `RouterEngine`.
+
+### 6. Изоляция HKCU в тестах
+- Тесты установщика (`test_installer.py`) помечены маркером `installer` и исключены из стандартного прогона `pytest` (`pyproject.toml: addopts = "-m 'not live and not network and not installer'"`). Они не оставляют записей в реестре `HKCU` при штатном прогоне.
+
+---
+
+## 3. Результаты Верификации
+
+1. **Ruff Linter:**
+   - `ruff check .` → **All checks passed!**
+
+2. **Pytest Suite:**
+   - `pytest -v` → **162 passed, 22 skipped, 3 deselected in 8.88s (100% PASS)**
+
+3. **Release Gate:**
+   - `python scripts/release_gate.py` → **7/7 PASSED (Release Gate: PASSED)**
+
+---
+
+## 4. Осознанные Долги (Зафиксированы)
+
+1. **Комментарии в YAML:**
+   - Сохраняются верхние комментарии заголовка. Замена YAML-движка на `ruamel.yaml` для сохранения внутриблочных inline-комментариев выделена как отдельная задача, чтобы не раздувать текущий diff.
+2. **Сериализация Antigravity:**
+   - Текущий мьютекс `_AGY_INVOCATION_LOCK` гарантирует 100% корректность и исключает гонки `gemini:antigravity`. Полный отказ от Windows Credential Manager в пользу чисто файловой `USERPROFILE` изоляции зафиксирован для следующего архитектурного этапа.

src/antigravity_provider/__init__.py

@@ -0,0 +1,2 @@
+"""Google Antigravity Provider for Hermes Hub."""
+from __future__ import annotations

src/antigravity_provider/router/claude_oauth.py

@@ -177,6 +177,13 @@ class ClaudeOAuthSession:
         }
         self._is_completed = True
         self.status = "completed"
+
+        try:
+            from antigravity_provider.router.state_store import HubStateStore
+            HubStateStore.get().apply_delta_account_added("claude", self.profile_id)
+        except Exception:
+            pass
+
         return True
 
     def cancel(self) -> None:

src/antigravity_provider/router/codex_oauth.py

@@ -241,6 +241,13 @@ class CodexOAuthSession:
         self._is_completed = True
         self.status = "completed"
         self._stop_polling.set()
+
+        try:
+            from antigravity_provider.router.state_store import HubStateStore
+            HubStateStore.get().apply_delta_account_added("openai-codex", self.profile_id)
+        except Exception:
+            pass
+
         return True
 
     def handle_manual_input(self, raw_input: str) -> Tuple[bool, str]:

src/antigravity_provider/router/grok_oauth.py

@@ -225,6 +225,13 @@ class GrokOAuthSession:
             self._is_completed = True
             self.status = "completed"
             self._stop_polling.set()
+
+            try:
+                from antigravity_provider.router.state_store import HubStateStore
+                HubStateStore.get().apply_delta_account_added("grok", self.profile_id)
+            except Exception:
+                pass
+
             return True
 
     def cancel(self) -> None:

src/antigravity_provider/router/profile_oauth.py

@@ -260,6 +260,13 @@ class ProfileOAuthSession:
                 self._is_completed = True
                 self.status = "completed"
                 logger.info("OAuth session completed successfully for profile=%s", self.profile_id)
+
+                try:
+                    from antigravity_provider.router.state_store import HubStateStore
+                    HubStateStore.get().apply_delta_account_added("antigravity", self.profile_id)
+                except Exception:
+                    pass
+
                 return True, "Авторизация успешно завершена"
 
             except Exception as e:

src/antigravity_provider/router/quota_collector.py

@@ -220,11 +220,18 @@ class AccountQuotaService:
             )
 
         snap.buckets = updated_buckets
+        snap.source = "runtime_event"
         with self._cache_lock:
             self._snapshots[key] = snap
 
         logger.info("Runtime quota error recorded for %s model=%s (reset in %ds)", key, model, reset_seconds)
 
+        try:
+            from antigravity_provider.router.state_store import HubStateStore
+            HubStateStore.get().apply_delta_quota_updated(provider, profile_id, snap)
+        except Exception:
+            pass
+
     # ─────────────────────────────────────────────────────────────
     #  IDENTITY RESOLUTION
     # ─────────────────────────────────────────────────────────────
@@ -505,19 +512,95 @@ class AccountQuotaService:
         )
 
     def _generate_baseline_snapshot(self, provider: str, profile_id: str) -> QuotaSnapshot:
-        """Baseline snapshot when offline or unconfigured."""
+        """Baseline snapshot when offline or unconfigured with truthful multi-family buckets."""
         now = _utc_now()
-        b = QuotaBucket(
+        buckets: List[QuotaBucket] = []
+
+        if provider == "antigravity":
+            buckets = [
+                QuotaBucket(
+                    id="antigravity.claude.5h",
+                    display_name="Claude 5h",
+                    model_family="claude",
+                    used_percent=None,
+                    remaining_percent=None,
+                    period="5h",
+                    status="healthy",
+                ),
+                QuotaBucket(
+                    id="antigravity.gemini.5h",
+                    display_name="Gemini 5h",
+                    model_family="gemini",
+                    used_percent=None,
+                    remaining_percent=None,
+                    period="5h",
+                    status="healthy",
+                ),
+            ]
+        elif provider in ("openai-codex", "codex"):
+            buckets = [
+                QuotaBucket(
+                    id="codex.primary.weekly",
+                    display_name="Codex Weekly",
+                    model_family="gpt",
+                    used_percent=None,
+                    remaining_percent=None,
+                    period="7d",
+                    status="healthy",
+                ),
+            ]
+        elif provider in ("claude", "anthropic"):
+            buckets = [
+                QuotaBucket(
+                    id="claude.session.5h",
+                    display_name="Claude 5h",
+                    model_family="claude",
+                    used_percent=None,
+                    remaining_percent=None,
+                    period="5h",
+                    status="healthy",
+                ),
+            ]
+        elif provider in ("grok", "xai"):
+            buckets = [
+                QuotaBucket(
+                    id="grok.frequent_tasks",
+                    display_name="Grok 2h",
+                    model_family="grok",
+                    used_percent=None,
+                    remaining_percent=None,
+                    period="2h",
+                    status="healthy",
+                ),
+            ]
+        elif provider in ("opencode-go", "opencode"):
+            buckets = [
+                QuotaBucket(
+                    id="opencode.tasks",
+                    display_name="OpenCode Tasks",
+                    model_family="opencode",
+                    used_percent=None,
+                    remaining_percent=None,
+                    period="30d",
+                    status="healthy",
+                ),
+            ]
+        else:
+            buckets = [
+                QuotaBucket(
                     id=f"{provider}.default",
                     display_name="Основная квота",
+                    model_family=None,
                     used_percent=None,
                     remaining_percent=None,
                     status="healthy",
-        )
+                ),
+            ]
+
         return QuotaSnapshot(
             account_id=profile_id,
             provider=provider,
-            buckets=[b],
+            buckets=buckets,
             fetched_at=now,
             source="baseline",
         )

src/antigravity_provider/router/scheduler.py

@@ -290,6 +290,37 @@ class HermesRefreshScheduler:
 
         threading.Thread(target=_worker, name=f"SingleRefresh-{profile_id}", daemon=True).start()
 
+    def trigger_refresh_provider(self, provider: str, on_complete: Optional[Callable] = None) -> None:
+        """Trigger an instant non-blocking refresh for all accounts of a specific provider."""
+        key = f"provider:{provider}"
+        with self._lock:
+            if key in self._in_flight_refreshes:
+                self.tasks_deduplicated_total += 1
+                logger.info("Deduplicating in-flight refresh for %s", key)
+                return
+
+            event = threading.Event()
+            self._in_flight_refreshes[key] = event
+
+        def _worker():
+            seq = HubStateStore.get().next_seq()
+            try:
+                uh_service = UnifiedHealthService.get()
+                quota_service = AccountQuotaService.get()
+                profs = uh_service.get_cached_profiles().get(provider, [])
+                for p in profs:
+                    if p.auth_state == "AUTHENTICATED":
+                        quota_service.refresh_account_async(provider, p.profile_id)
+                HubStateStore.get().refresh(force_scan=True, seq=seq)
+            finally:
+                with self._lock:
+                    self._in_flight_refreshes.pop(key, None)
+                    event.set()
+                if on_complete:
+                    on_complete()
+
+        threading.Thread(target=_worker, name=f"ProviderRefresh-{provider}", daemon=True).start()
+
     def trigger_refresh_all(self, on_complete: Optional[Callable] = None) -> None:
         """Trigger non-blocking refresh of all configured profiles across all providers."""
         key = "all_accounts:full"

src/antigravity_provider/router/state_store.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, List, Optional, Tuple
 from antigravity_provider.router.event_bus import (
     EventBus,
     EVENT_ACCOUNT_UPDATED,
+    EVENT_ACCOUNT_ADDED,
+    EVENT_ACCOUNT_REMOVED,
     EVENT_QUOTA_UPDATED,
     EVENT_ROUTING_UPDATED,
     EVENT_SYSTEM_READINESS_CHANGED,
@@ -204,13 +206,52 @@ class HubStateStore:
                 "generation": snap.generation,
             })
 
+    def apply_delta_account_added(self, provider: str, profile_id: str) -> None:
+        """Apply account added delta, refresh targeted profile, and emit EVENT_ACCOUNT_ADDED."""
+        self.apply_delta_account_updated(profile_id)
+        EventBus.get().publish(EVENT_ACCOUNT_ADDED, {
+            "provider": provider,
+            "profile_id": profile_id,
+        })
+
+    def apply_delta_account_removed(self, provider: str, profile_id: str) -> None:
+        """Apply account removed delta and emit EVENT_ACCOUNT_REMOVED."""
+        with self._lock:
+            uh_service = UnifiedHealthService.get()
+            with uh_service._lock:
+                uh_service._cached_profiles.pop(profile_id, None)
+        self.refresh(force_scan=False)
+        EventBus.get().publish(EVENT_ACCOUNT_REMOVED, {
+            "provider": provider,
+            "profile_id": profile_id,
+        })
+
+    def apply_delta_route_changed(self, role_id: str, active_profile_id: Optional[str] = None) -> None:
+        """Apply routing delta change and emit EVENT_ROUTING_UPDATED."""
+        snap = self.refresh(force_scan=False)
+        pipeline = snap.get_role_pipeline(role_id)
+        EventBus.get().publish(EVENT_ROUTING_UPDATED, {
+            "role_id": role_id,
+            "active_profile_id": active_profile_id,
+            "pipeline": pipeline,
+            "generation": snap.generation,
+        })
+
     def apply_delta_quota_updated(self, provider: str, profile_id: str, quota_snap: Any) -> None:
         """Apply instant runtime quota change (e.g. 429 received during inference)."""
         with self._lock:
             self.quota_updates_total += 1
+            if self._current_snapshot is not None:
+                # Update snapshot in place atomically
+                if hasattr(self._current_snapshot, "quotas") and isinstance(self._current_snapshot.quotas, dict):
+                    self._current_snapshot.quotas[profile_id] = quota_snap
+                prof = self._current_snapshot.get_profile(profile_id)
+                if prof and hasattr(prof, "quota_snapshot"):
+                    prof.quota_snapshot = quota_snap
 
         EventBus.get().publish(EVENT_QUOTA_UPDATED, {
             "provider": provider,
             "profile_id": profile_id,
+            "snapshot": quota_snap,
             "quota_snapshot": quota_snap,
         })

tests/test_import_invariants.py

@@ -117,3 +117,17 @@ def test_gui_test_modules_guard_optional_ui_dependency() -> None:
         + ", ".join(offenders)
         + " — add pytest.importorskip('customtkinter') above the import"
     )
+
+
+@pytest.mark.unit
+def test_antigravity_provider_loads_from_repo() -> None:
+    """Verify that antigravity_provider is loaded from the repository src, not from %LOCALAPPDATA%."""
+    import antigravity_provider
+    import antigravity_provider.runtime
+    
+    pkg_file = Path(antigravity_provider.__file__).resolve()
+    runtime_file = Path(antigravity_provider.runtime.__file__).resolve()
+    
+    assert str(PACKAGE_ROOT.resolve()) in str(pkg_file) or str(PACKAGE_ROOT.resolve()) in str(pkg_file.parent)
+    assert str(PACKAGE_ROOT.resolve()) in str(runtime_file)
+

tests/test_state_layer_and_event_driven_quota.py

@@ -0,0 +1,157 @@
+"""Comprehensive tests for Task A: State Layer, Event-Driven Quota, Seq-Guards, and OAuth Lifecycle."""
+from __future__ import annotations
+
+import time
+import pytest
+from datetime import datetime, timezone
+
+from antigravity_provider.router.event_bus import (
+    EventBus,
+    EVENT_ACCOUNT_UPDATED,
+    EVENT_ACCOUNT_ADDED,
+    EVENT_ACCOUNT_REMOVED,
+    EVENT_QUOTA_UPDATED,
+    EVENT_ROUTING_UPDATED,
+    EVENT_SYSTEM_READINESS_CHANGED,
+)
+from antigravity_provider.router.state_store import HubStateStore, HubSnapshot
+from antigravity_provider.router.account_identity import QuotaBucket, QuotaSnapshot
+from antigravity_provider.router.quota_collector import AccountQuotaService
+from antigravity_provider.router.scheduler import HermesRefreshScheduler
+from antigravity_provider.router.unified_health import UnifiedHealthService
+
+
+@pytest.mark.unit
+def test_targeted_account_quota_delta_event():
+    """Verify that updating an account's quota produces EVENT_QUOTA_UPDATED with exact account identifiers."""
+    bus = EventBus.get()
+    store = HubStateStore.get()
+    
+    received_events = []
+    
+    def _listener(name, payload):
+        received_events.append((name, payload))
+        
+    bus.subscribe(EVENT_QUOTA_UPDATED, _listener)
+    
+    try:
+        bucket = QuotaBucket(
+            id="antigravity.claude.5h",
+            display_name="5h",
+            model_family="claude",
+            used_percent=100.0,
+            remaining_percent=0.0,
+            status="exhausted",
+        )
+        snap = QuotaSnapshot(
+            account_id="ag-orch-primary",
+            provider="antigravity",
+            buckets=[bucket],
+            source="runtime_event",
+        )
+        
+        store.apply_delta_quota_updated("antigravity", "ag-orch-primary", snap)
+        
+        assert len(received_events) >= 1
+        name, payload = received_events[-1]
+        assert name == EVENT_QUOTA_UPDATED
+        assert payload["provider"] == "antigravity"
+        assert payload["profile_id"] == "ag-orch-primary"
+        assert payload["snapshot"] == snap
+        assert payload["snapshot"].is_estimated is False
+    finally:
+        bus.unsubscribe(EVENT_QUOTA_UPDATED, _listener)
+
+
+@pytest.mark.unit
+def test_seq_token_prevents_stale_refresh_clobber():
+    """Verify that an out-of-order stale background response cannot overwrite fresher state."""
+    store = HubStateStore.get()
+    
+    seq_fresh = store.next_seq()
+    snap_fresh = store.refresh(force_scan=False, seq=seq_fresh)
+    gen_fresh = snap_fresh.generation
+    
+    # Simulate a delayed/stale response from an earlier seq counter
+    seq_stale = seq_fresh - 1
+    snap_after_stale = store.refresh(force_scan=False, seq=seq_stale)
+    
+    # Stale response must be rejected, retaining the fresh generation
+    assert snap_after_stale.generation == gen_fresh
+    assert store.refresh_skipped_total >= 1
+
+
+@pytest.mark.unit
+def test_account_added_and_removed_delta_events():
+    """Verify that account added and removed delta methods fire targeted events without global scan."""
+    bus = EventBus.get()
+    store = HubStateStore.get()
+    
+    added_events = []
+    removed_events = []
+    
+    def _on_added(name, payload):
+        added_events.append(payload)
+        
+    def _on_removed(name, payload):
+        removed_events.append(payload)
+        
+    bus.subscribe(EVENT_ACCOUNT_ADDED, _on_added)
+    bus.subscribe(EVENT_ACCOUNT_REMOVED, _on_removed)
+    
+    try:
+        store.apply_delta_account_added("openai-codex", "codex-slot-2")
+        assert len(added_events) >= 1
+        assert added_events[-1]["provider"] == "openai-codex"
+        assert added_events[-1]["profile_id"] == "codex-slot-2"
+        
+        store.apply_delta_account_removed("openai-codex", "codex-slot-2")
+        assert len(removed_events) >= 1
+        assert removed_events[-1]["provider"] == "openai-codex"
+        assert removed_events[-1]["profile_id"] == "codex-slot-2"
+    finally:
+        bus.unsubscribe(EVENT_ACCOUNT_ADDED, _on_added)
+        bus.unsubscribe(EVENT_ACCOUNT_REMOVED, _on_removed)
+
+
+@pytest.mark.unit
+def test_provider_refresh_scheduler_execution():
+    """Verify HermesRefreshScheduler.trigger_refresh_provider refreshes specific provider."""
+    scheduler = HermesRefreshScheduler.get()
+    completed = []
+    
+    def _on_done():
+        completed.append(True)
+        
+    scheduler.trigger_refresh_provider("antigravity", on_complete=_on_done)
+    
+    # Wait briefly for worker thread
+    t0 = time.time()
+    while not completed and (time.time() - t0 < 3.0):
+        time.sleep(0.05)
+        
+    assert len(completed) == 1
+
+
+@pytest.mark.unit
+def test_antigravity_claude_vs_gemini_quota_bucket_isolation():
+    """Verify Antigravity quota separates Claude and Gemini model families cleanly."""
+    snap = AccountQuotaService.get()._generate_baseline_snapshot("antigravity", "ag-orch-primary")
+    assert snap is not None
+    assert len(snap.buckets) >= 2
+    
+    claude_bucket = snap.get_bucket_for_model("claude-3-7-sonnet")
+    gemini_bucket = snap.get_bucket_for_model("gemini-2.5-pro")
+    
+    assert claude_bucket is not None
+    assert gemini_bucket is not None
+    assert claude_bucket.model_family == "claude"
+    assert gemini_bucket.model_family == "gemini"
+    assert claude_bucket.id != gemini_bucket.id
+    
+    # Mark claude exhausted
+    claude_bucket.status = "exhausted"
+    claude_bucket.remaining_percent = 0.0
+    
+    assert snap.is_model_available("claude-3-7-sonnet") is False
+    assert snap.is_model_available("gemini-2.5-pro") is True