Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
fix(steer): keep Send Now usable when optional Memory runtime is unavailable (#2090)
rkrkrkkfac123a6482e
diff --git a/core/session_turns.py b/core/session_turns.pyindex 0a6b8e729..0cf25d3c8 100644--- a/core/session_turns.py+++ b/core/session_turns.py@@ -2690,21 +2690,34 @@ class SessionTurnManager:def _compatible_steer_memory_authority(self, turn_id: str, deliveries: list[dict[str, Any]]) -> bool:if not bool(getattr(getattr(self.controller.config, "memory", None), "enabled", False)):return True- from avibe_memory.admission import InboundTurnFacts++ memory_available = (+ getattr(self.controller, "memory_runtime", None) is not None+ and getattr(self.controller, "_memory_implementation_error", None) is None+ )+ if memory_available:+ from avibe_memory.admission import InboundTurnFacts+ admission = self.controller._memory_admission()++ def admits(owner: dict[str, Any]) -> bool:+ return admission.admits(InboundTurnFacts(**owner))+ else:++ def admits(_owner: dict[str, Any]) -> bool:+ return Falsewith self._sqlite_engine().connect() as conn:initial = delivery_store.delivery_for_turn(conn, turn_id)active = delivery_store.execution_delivery_payload(conn, initial) if initial else {}incoming = [delivery_store.execution_delivery_payload(conn, row) for row in deliveries]payloads = [active, *incoming]- admission = self.controller._memory_admission()delegated = [delivery_store.memory_owner_from_payload(payload)for payload in payloads if payload.get("source") == "harness"]# Revoking a binding must not let foreign input enter a native Turn whose# existing scope could become readable again when access is restored.has_scope = active.get("session_id") in getattr(self.controller, "_memory_scopes_by_session", {})- if not any(owner and (has_scope or admission.admits(InboundTurnFacts(**owner))) for owner in delegated):- return True # Human-only and Memory-ineligible group steering keep their policy.+ if not any(owner and (has_scope or admits(owner)) for owner in delegated):+ return True # Human-only and Memory-ineligible steering keep their policy.authority = delivery_store.memory_authority_for_payload(active)return all(delivery_store.memory_authority_for_payload(payload) == authority for payload in incoming)diff --git a/tests/test_session_delivery_fsm.py b/tests/test_session_delivery_fsm.pyindex 9d18d4336..d66d763be 100644--- a/tests/test_session_delivery_fsm.py+++ b/tests/test_session_delivery_fsm.py@@ -4,6 +4,7 @@ import asyncioimport gcimport jsonimport sqlite3+import sysimport threadingfrom concurrent.futures import ThreadPoolExecutorfrom contextlib import asynccontextmanager, closing@@ -67,6 +68,10 @@ from storage.models import (session_turns,show_session_events,)+from vibe.memory_contract import (+ MemoryImplementationIncompatibleError,+ MemoryImplementationUnavailableError,+)@pytest.fixture@@ -79,6 +84,8 @@ class _Controller:self.command_handler = SimpleNamespace(handle_stop=AsyncMock(return_value=True))self.agent_service = SimpleNamespace(agents={}, _turn_gates={})self.config = SimpleNamespace(language="en")+ self.memory_runtime = SimpleNamespace()+ self._memory_implementation_error = Noneself.statuses: list[tuple[str, str]] = []@staticmethod@@ -485,6 +492,44 @@ def _row(engine, delivery_id: str) -> dict:return row+def _steer_memory_payload(+ *,+ source: str,+ owner: dict[str, object] | None = None,+ resource_user_context: dict[str, object] | None = None,+) -> dict[str, object]:+ metadata: dict[str, object] = {}+ if owner is not None:+ message_metadata: dict[str, object] = {"delegated_memory_owner": owner}+ if resource_user_context is not None:+ message_metadata["resource_user_context"] = resource_user_context+ metadata["scheduled_provenance"] = {+ "platform_specific": {+ "task_trigger_kind": "watch",+ "message_metadata": message_metadata,+ }+ }+ return {"session_id": "ses_fsm", "source": source, "metadata": metadata}+++def _stub_steer_memory_payloads(+ monkeypatch: pytest.MonkeyPatch,+ active: dict[str, object],+ incoming: dict[str, object],+) -> list[dict[str, object]]:+ monkeypatch.setattr(+ delivery_store,+ "delivery_for_turn",+ lambda _conn, _turn_id: {"id": "active"},+ )+ monkeypatch.setattr(+ delivery_store,+ "execution_delivery_payload",+ lambda _conn, row: active if row["id"] == "active" else row,+ )+ return [incoming]++def _configure_activation_owner(manager: SessionTurnManager,registry: RuntimeActivationRegistry,@@ -1309,6 +1354,174 @@ async def test_steering_memory_check_failure_restores_a_retryable_queue_row(manaassert queued[0]["current_attempt_id"] is None+ "implementation_error",+ [MemoryImplementationUnavailableError("missing"), MemoryImplementationIncompatibleError("incompatible")],+)+def test_steer_memory_unavailable_keeps_human_input_independent_of_optional_import(+ managers,+ monkeypatch,+ implementation_error,+):+ manager, _other, _engine, _engine_b, _starts = managers+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller.memory_runtime = None+ manager.controller._memory_implementation_error = implementation_error+ manager.controller._memory_admission = Mock(side_effect=AssertionError("Memory admission must not be called"))+ active = _steer_memory_payload(source="user")+ incoming = _steer_memory_payload(source="user")+ incoming["id"] = "incoming"+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)++ with patch.dict(sys.modules, {"avibe_memory.admission": None}):+ assert manager._compatible_steer_memory_authority("turn", deliveries)+ manager.controller._memory_admission.assert_not_called()+++ ("incoming_owner", "incoming_resource", "expected"),+ [+ ({"platform": "avibe", "user_id": "local", "is_dm": False}, None, True),+ ({"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, None, True),+ ({"platform": "avibe", "user_id": "local", "is_dm": False}, {"sub": "other"}, True),+ ],+)+def test_steer_memory_unavailable_keeps_delegated_policy_without_readable_scope(+ managers,+ monkeypatch,+ incoming_owner,+ incoming_resource,+ expected,+):+ manager, _other, _engine, _engine_b, _starts = managers+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller.memory_runtime = None+ manager.controller._memory_implementation_error = MemoryImplementationUnavailableError("missing")+ manager.controller._memory_scopes_by_session = {}+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}+ resource = {"sub": "local"}+ active = _steer_memory_payload(+ source="harness",+ owner=owner,+ resource_user_context=resource,+ )+ incoming = _steer_memory_payload(+ source="harness",+ owner=incoming_owner,+ resource_user_context=incoming_resource if incoming_resource is not None else resource,+ )+ incoming["id"] = "incoming"+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)++ assert manager._compatible_steer_memory_authority("turn", deliveries) is expected+++ ("incoming_owner", "incoming_resource"),+ [+ ({"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, None),+ ({"platform": "avibe", "user_id": "local", "is_dm": False}, {"sub": "other"}),+ ],+)+def test_steer_memory_unavailable_preserves_recorded_scope_boundaries(+ managers,+ monkeypatch,+ incoming_owner,+ incoming_resource,+):+ manager, _other, _engine, _engine_b, _starts = managers+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller.memory_runtime = None+ manager.controller._memory_implementation_error = MemoryImplementationUnavailableError("missing")+ manager.controller._memory_scopes_by_session = {"ses_fsm": object()}+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}+ active = _steer_memory_payload(+ source="harness",+ owner=owner,+ resource_user_context={"sub": "local"},+ )+ incoming = _steer_memory_payload(+ source="harness",+ owner=incoming_owner,+ resource_user_context=incoming_resource or {"sub": "local"},+ )+ incoming["id"] = "incoming"+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)++ assert manager._compatible_steer_memory_authority("turn", deliveries) is False+++async def test_steering_memory_admission_failure_restores_retryable_queue_row(managers):+ manager, _other, engine, _engine_b, _starts = managers+ await _activate(manager, text="active")+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller.memory_runtime = SimpleNamespace()+ manager.controller._memory_implementation_error = None+ manager.controller._memory_admission = Mock(side_effect=RuntimeError("admission unavailable"))+ manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))++ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}+ result = await manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p1",+ content="retry after admission failure",+ source="harness",+ author="harness",+ message_type="harness",+ metadata={+ "scheduled_provenance": {+ "platform_specific": {+ "task_trigger_kind": "watch",+ "message_metadata": {"delegated_memory_owner": owner},+ }+ }+ },+ ),+ context=_context(),+ )++ assert result.state == "queued"+ manager._steer.assert_not_awaited()+ queued = [row for row in _rows(engine) if row["state"] == "queued"]+ assert len(queued) == 1+ events = json.loads(queued[0]["delivery_history_json"])["events"]+ assert events[-1]["receipt"]["reason"] == "memory_runtime_unavailable"+++ ("admitted", "incoming_owner", "expected"),+ [+ (True, {"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, False),+ (True, {"platform": "avibe", "user_id": "local", "is_dm": False}, True),+ (False, {"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, True),+ ],+)+def test_steer_memory_available_retains_admission_authority_semantics(+ managers,+ monkeypatch,+ admitted,+ incoming_owner,+ expected,+):+ manager, _other, _engine, _engine_b, _starts = managers+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller.memory_runtime = SimpleNamespace()+ manager.controller._memory_implementation_error = None+ admission = Mock()+ admission.admits.return_value = admitted+ manager.controller._memory_admission = Mock(return_value=admission)+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}+ active = _steer_memory_payload(source="harness", owner=owner)+ incoming = _steer_memory_payload(source="harness", owner=incoming_owner)+ incoming["id"] = "incoming"+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)++ assert manager._compatible_steer_memory_authority("turn", deliveries) is expected+ assert admission.admits.call_count >= 1++def test_persisted_start_attempt_reaches_dispatch_context(managers) -> None:manager, _other, engine, _engine_b, _starts = managerscaptured: dict[str, object] = {}