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(memory): take the Memory authority gate off the delivery path (#2109)
rkrkrkk613f76ab7e6b
diff --git a/core/controller.py b/core/controller.pyindex f0d134a50..aa30c900f 100644--- a/core/controller.py+++ b/core/controller.py@@ -3499,6 +3499,24 @@ class Controller:return Nonesession_key = str(session_id or "").strip()implementation_sessions = getattr(self, "_memory_implementation_cli_sessions", None)+ try:+ from storage.message_deliveries import current_turn_memory_authority_conflict++ authority_conflict = current_turn_memory_authority_conflict(session_key)+ except Exception:+ # The Memory boundary fails closed: an unanswerable isolation check+ # denies this call only. The cached scope is kept so a transient+ # storage failure does not permanently revoke the owner's access.+ logger.debug(+ "memory scope delivery-authority check failed for session=%s",+ session_key,+ exc_info=True,+ )+ return None+ if authority_conflict:+ # Denial is per active Turn and re-evaluated on every call; the+ # recorded scope stays so the owner's next Turn is readable again.+ return Noneif (getattr(self, "_memory_implementation_error", None) is not Noneand isinstance(implementation_sessions, set)diff --git a/core/session_turns.py b/core/session_turns.pyindex 0cf25d3c8..4a9bb1024 100644--- a/core/session_turns.py+++ b/core/session_turns.py@@ -2687,40 +2687,6 @@ class SessionTurnManager:error_type=type(exc).__name__,)- 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-- 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 False-- with 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]- 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 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)-async def _dispatch_steer_batch(self,backend: str,@@ -2735,33 +2701,6 @@ class SessionTurnManager:# The steering claim has committed. Other viewers must see the same# read-only pending row while the native write is in flight.self._publish_queue_update(str(deliveries[0]["session_id"]))- try:- memory_authority_compatible = self._compatible_steer_memory_authority(- logical_turn_id,- deliveries,- )- except Exception as exc:- # An unavailable optional Memory runtime must not strand a claimed- # Delivery in ``steering``. No native write has happened yet, so- # this is a definitive refusal and the exact input can safely- # return to the retryable FIFO queue.- logger.exception(- "steering memory-authority check failed before native write for delivery=%s",- delivery_id,- )- return await self._finish_steer(- delivery_id,- steer_result(- SteerOutcome.REFUSED,- reason="memory_runtime_unavailable",- error_type=type(exc).__name__,- ),- context=context,- )- if not memory_authority_compatible:- return await self._finish_steer(- delivery_id, steer_result(SteerOutcome.REFUSED, reason="memory_authority_changed"), context=context- )try:from core.workbench_media import file_attachments_from_specs, resolve_attachment_specsdiff --git a/docs/plans/2026-09-22-memory-zero-impact-delivery.md b/docs/plans/2026-09-22-memory-zero-impact-delivery.mdnew file mode 100644index 000000000..d983e2db0--- /dev/null+++ b/docs/plans/2026-09-22-memory-zero-impact-delivery.md@@ -0,0 +1,52 @@+# Memory zero-impact delivery++## Background++PR #2023 put a Memory authority comparison in the native steer admission path.+PRs #2088 and #2090 narrowed the unavailable-runtime behavior, but the design+still let an optional Memory subsystem refuse a host-owned message delivery.++## Owner decision++Memory has zero influence on Avibe message delivery. Once host-owned routing and+identity checks pass, steer, P0, P1, and P3 delivery proceeds for every Memory+state. If the input would cross the authority of a readable Memory scope, the+Turn remains delivered and Memory access for that Turn/session is denied.++## Invariant++For every Memory state, a delivery has the same `DeliveryResult.state` as the+same admission with Memory disabled. Memory may deny reads or writes at its+boundary, but it cannot change delivery admission, native steering, or queue+ownership.++## Mechanism++`core/session_turns.py` no longer imports `avibe_memory`, calls+`Controller._memory_admission`, or emits Memory-specific refusal reasons. The+Memory boundary evaluates the active Turn's immutable delivery rows at+consumption time. A host-owned storage helper compares the initial delivery's+authority with every delivery that may already be in the Turn (`accepted`,+`steering`, `reconciling_steer`); definitively unwritten rows (`queued`,+`pending_steer`) are ignored. On a conflict, or when the check cannot be+evaluated, Memory scope resolution returns no scope for that call, so internal+Memory endpoints answer 403 while the conflicting Turn is active. The cached+owner scope is preserved and re-evaluated on every call, so the owner's next+Turn is readable again without re-admission.++## Tests and evidence++- Unit: the steer path reaches the native write with `_memory_admission`+ patched to raise; a parametrized delivery invariant covers disabled, missing,+ incompatible, runtime-raising, conflicting, and matching Memory states across+ P0, P1, and P3.+- Contract: delegated lifecycle cases now assert accepted delivery plus denied+ Memory scope for cross-owner steering; matching authority remains readable.+- Scenario: active-poll recovery and delegated continuation exercise the+ consumption-time scope check through `/internal/memory/search`.+- Residual manual check: verify one accepted cross-owner steer in a running+ service and confirm the Turn's `vibe memory` request receives 403.++The cross-owner/cross-scope delivery-fence assertions from PR #2090 were moved+to the Memory-scope layer; the delivery FSM retains only the delivery-state+invariant and native-write structural assertion.diff --git a/storage/message_deliveries.py b/storage/message_deliveries.pyindex b5f3ad6c8..f4e431e98 100644--- a/storage/message_deliveries.py+++ b/storage/message_deliveries.py@@ -29,6 +29,12 @@ from storage.models import (TURN_OWNER_STATES = ("starting", "active")+# Delivery states whose input may have reached the native Turn. ``steering``+# and ``reconciling_steer`` count: the adapter may already have written the+# prompt and returned an unknown acknowledgement. Only ``queued`` and+# ``pending_steer`` are definitively unwritten.+POSSIBLY_WRITTEN_DELIVERY_STATES = frozenset({"accepted", "steering", "reconciling_steer"})+UNWRITTEN_STEER_STATES = frozenset({"queued", "pending_steer"})FAILURE_RETRY_HISTORY_KIND = "backend_failure_retry"WEB_PUSH_USER_KEY_METADATA = "_web_push_user_key"WEB_PUSH_USER_KEYS_METADATA = "_web_push_user_keys"@@ -624,6 +630,42 @@ def current_delivery_memory_owner(session_id: str, *, turn_id: str | None = Nonereturn memory_owner_from_payload(payload)+def current_turn_memory_authority_conflict(session_id: str) -> bool:+ """Return whether an active Turn carries an owner from another authority.++ This is deliberately a read-only host-side check for the Memory boundary.+ Delivery admission and native steering must not call Memory or consult this+ helper; the boundary evaluates the immutable delivery rows at consumption+ time instead.+ """++ from storage.db import get_cached_sqlite_engine++ with get_cached_sqlite_engine().connect() as conn:+ turn = active_turn(conn, session_id)+ if not turn:+ return False+ initial = delivery_for_turn(conn, str(turn["id"]))+ if initial is None:+ return False+ initial_payload = execution_delivery_payload(conn, initial)+ initial_authority = memory_authority_for_payload(initial_payload)+ initial_owner = memory_owner_from_payload(initial_payload)+ for delivery in deliveries_for_turn(conn, str(turn["id"])):+ # Only an input that may already be in the native Turn can carry+ # foreign authority into it; a definitively unwritten row cannot.+ if delivery.get("state") not in POSSIBLY_WRITTEN_DELIVERY_STATES:+ continue+ payload = execution_delivery_payload(conn, delivery)+ if (+ delivery.get("id") != initial.get("id")+ and (initial_owner is not None or memory_owner_from_payload(payload) is not None)+ and memory_authority_for_payload(payload) != initial_authority+ ):+ return True+ return False++def execution_delivery_payload(conn: Connection, delivery: dict[str, Any]) -> dict[str, Any]:"""Read this exact Delivery's immutable content, including after acceptance."""snapshot = message_for_delivery(conn, delivery) if delivery.get("message_id") else Nonediff --git a/tests/test_memory_delegated_lifecycle.py b/tests/test_memory_delegated_lifecycle.pyindex d0ab73566..7bec7e58d 100644--- a/tests/test_memory_delegated_lifecycle.py+++ b/tests/test_memory_delegated_lifecycle.py@@ -200,23 +200,107 @@ def test_steering_preserves_effective_memory_authority(active_delegated, user, masyncio.run(manager._run_pending_steers("ses_fsm", active.turn_id, _context()))with engine.connect() as conn:state = message_deliveries.get_delivery(conn, result.delivery_id)["state"]- assert asyncio.run(_search(controller)) == scope+ assert state == "accepted"+ manager._steer.assert_awaited_once()if user == "local":- assert state == "accepted"- manager._steer.assert_awaited_once()+ assert asyncio.run(_search(controller)) == scopeelse:- assert state == "queued"- manager._steer.assert_not_called()- next_scopes = []+ asyncio.run(_search(controller, status=403))+ # Denial is per active Turn, not a revocation of the owner's scope.+ assert "ses_fsm" in controller._memory_scopes_by_session+++def test_unwritten_cross_authority_steer_keeps_owner_scope_readable(active_delegated):+ """A provisional steer row cannot deny the owner's Memory before any native write."""+ manager, _, engine, controller, task, active, tmp = active_delegated+ scope = asyncio.run(_search(controller))+ result = asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="incoming request",+ author_id="remote:bob",+ message_kind="original",+ ),+ context=_context(),+ )+ )+ from storage import message_deliveries++ with engine.begin() as conn:+ message_deliveries.open_pending_steer_batch(+ conn,+ deliveries=[message_deliveries.get_delivery(conn, result.delivery_id)],+ turn_id=active.turn_id,+ attempt_id=message_deliveries.new_attempt_id(),+ )+ with engine.connect() as conn:+ assert message_deliveries.get_delivery(conn, result.delivery_id)["state"] == "pending_steer"+ assert asyncio.run(_search(controller)) == scope- async def following(_s, ctx, _text, **_kw):- admitted = configure_memory_cli_access(controller, ctx)- next_scopes.append(await _search(controller, status=200 if admitted else 403))- manager._run = following- manager.controller.config.memory = SimpleNamespace(enabled=True)- asyncio.run(manager.terminalize_turn(active.turn_id))- assert len(next_scopes) == 1 and next_scopes[0] != scope[email protected]("state", ["steering", "reconciling_steer"])+def test_possibly_written_cross_authority_steer_denies_memory(active_delegated, state):+ """An in-flight or unresolved native write is treated as already in the Turn."""+ manager, _, engine, controller, task, active, tmp = active_delegated+ asyncio.run(_search(controller))+ result = asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="incoming request",+ author_id="remote:bob",+ message_kind="original",+ ),+ context=_context(),+ )+ )+ from sqlalchemy import update++ from storage import message_deliveries+ from storage.models import message_deliveries as table++ with engine.begin() as conn:+ conn.execute(+ update(table)+ .where(table.c.id == result.delivery_id)+ .values(+ state=state,+ current_attempt_id=message_deliveries.new_attempt_id(),+ current_attempt_kind="steer",+ current_target_turn_id=active.turn_id,+ current_expected_native_turn_id="opencode:oc-1:1",+ )+ )+ asyncio.run(_search(controller, status=403))+ assert "ses_fsm" in controller._memory_scopes_by_session+++def test_written_state_sets_partition_every_steer_state():+ """The two declarations are the single source of truth for the boundary."""+ from storage.message_deliveries import POSSIBLY_WRITTEN_DELIVERY_STATES, UNWRITTEN_STEER_STATES++ assert not (POSSIBLY_WRITTEN_DELIVERY_STATES & UNWRITTEN_STEER_STATES)+ assert POSSIBLY_WRITTEN_DELIVERY_STATES | UNWRITTEN_STEER_STATES == {+ "accepted", "steering", "reconciling_steer", "queued", "pending_steer",+ }+++def test_unanswerable_authority_check_fails_closed_without_revoking(active_delegated):+ """The Memory boundary denies the call, and only the call, when isolation cannot be evaluated."""+ manager, _, engine, controller, task, active, tmp = active_delegated+ scope = asyncio.run(_search(controller))+ from unittest.mock import patch++ def boom(_session_id):+ raise RuntimeError("storage unavailable")++ with patch("storage.message_deliveries.current_turn_memory_authority_conflict", boom):+ asyncio.run(_search(controller, status=403))+ assert "ses_fsm" in controller._memory_scopes_by_session+ assert asyncio.run(_search(controller)) == scope@pytest.mark.parametrize("active_delegated", ["create_once"], indirect=True)@@ -371,9 +455,9 @@ def test_active_poll_restores_proof_and_read_scope(active_delegated, monkeypatch),context=_context(),)- assert result.state == "queued"- new.session_turns._steer.assert_not_called()- await _search(new)+ assert result.state == "accepted"+ new.session_turns._steer.assert_awaited_once()+ await _search(new, status=403)release.set()await asyncio.gather(*agent._active_requests.values())@@ -385,7 +469,7 @@ def test_active_poll_restores_proof_and_read_scope(active_delegated, monkeypatchassert verify_caller_session_proof("ses_fsm", bound[0]["extra_env"]["AVIBE_CALLER_SESSION_PROOF"], {"platform": "avibe", "user_id": "local"})- assert new.memory_search_payload.await_count == 2+ assert new.memory_search_payload.await_count == 1@pytest.mark.parametrize("active_delegated", ["remote"], indirect=True)diff --git a/tests/test_memory_disabled_isolation.py b/tests/test_memory_disabled_isolation.pyindex 95ed63cca..2335e631d 100644--- a/tests/test_memory_disabled_isolation.py+++ b/tests/test_memory_disabled_isolation.py@@ -142,7 +142,9 @@ def test_memory_state_inventory_keeps_runtime_assets_and_lock_lookalikes(assert Path(relative_path) in _memory_state_entries(tmp_path)-def test_memory_cli_session_keeps_authenticated_boundary_when_implementation_is_unavailable() -> None:+def test_memory_cli_session_keeps_authenticated_boundary_when_implementation_is_unavailable(monkeypatch) -> None:+ # This controller owns no delivery store; the Turn-authority check is not under test here.+ monkeypatch.setattr("storage.message_deliveries.current_turn_memory_authority_conflict", lambda _sid: False)controller = Controller.__new__(Controller)controller.config = types.SimpleNamespace(memory=types.SimpleNamespace(enabled=True),diff --git a/tests/test_reply_enhancer_platform.py b/tests/test_reply_enhancer_platform.pyindex 3464f6b6d..7489f11f6 100644--- a/tests/test_reply_enhancer_platform.py+++ b/tests/test_reply_enhancer_platform.py@@ -500,6 +500,13 @@ class ReplyEnhancerPlatformTests(unittest.IsolatedAsyncioTestCase):self.assertFalse(configure_memory_cli_access(controller, workbench))def test_memory_cli_access_associates_and_revokes_session_scope(self):+ from unittest.mock import patch++ # This controller owns no delivery store; the Turn-authority check is not under test here.+ with patch("storage.message_deliveries.current_turn_memory_authority_conflict", lambda _sid: False):+ self._assert_memory_cli_access_associates_and_revokes_session_scope()++ def _assert_memory_cli_access_associates_and_revokes_session_scope(self):principal_id = "u-11111111111111111111111111111111"project_id = "p-22222222222222222222222222222222"binding_enabled = Truediff --git a/tests/test_session_delivery_fsm.py b/tests/test_session_delivery_fsm.pyindex d66d763be..8c9548875 100644--- a/tests/test_session_delivery_fsm.py+++ b/tests/test_session_delivery_fsm.py@@ -4,7 +4,6 @@ import asyncioimport gcimport jsonimport sqlite3-import sysimport threadingfrom concurrent.futures import ThreadPoolExecutorfrom contextlib import asynccontextmanager, closing@@ -492,44 +491,6 @@ 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,@@ -1329,197 +1290,80 @@ async def test_steering_preparation_failure_preserves_a_definitively_unwritten_b@pytest.mark.anyio-async def test_steering_memory_check_failure_restores_a_retryable_queue_row(managers):- manager, _other, engine, _engine_b, _starts = managers- await _activate(manager, text="active")- manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))- manager._compatible_steer_memory_authority = Mock(- side_effect=ModuleNotFoundError("avibe_memory")[email protected]("priority", ["p0", "p1", "p3"])+async def test_delivery_path_reaches_native_write_without_memory_admission(managers, priority):+ """Memory is not consulted by any delivery priority."""++ manager, _other, _engine, _engine_b, _starts = managers+ if priority == "p1":+ await _activate(manager, text="active")+ manager.controller._memory_admission = Mock(+ side_effect=AssertionError("Memory admission must not be called"))+ manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))result = await manager.deliver(DeliveryRequest(session_id="ses_fsm",- priority="p1",- content="retry after memory recovery",+ priority=priority,+ content="steer" if priority != "p0" else "replacement",),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- assert queued[0]["dispatch_text"] == "retry after memory recovery"- assert 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)+ assert result.state == ("accepted" if priority == "p1" else "claimed")+ if priority == "p1":+ manager._steer.assert_awaited_once()+ else:+ manager._steer.assert_not_awaited()manager.controller._memory_admission.assert_not_called()[email protected]("priority", ["p0", "p1", "p3"])@pytest.mark.parametrize(- ("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),- ],+ "memory_state",+ ["disabled", "missing", "incompatible", "runtime_raising", "conflicting", "matching"],)-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+async def test_delivery_state_is_memory_independent(managers, priority, memory_state):+ """Every Memory state preserves the delivery result of the disabled path."""-- ("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"))+ await _activate(manager, text="active") if priority == "p1" else Nonemanager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))+ manager.controller._memory_admission = Mock()+ admission = Mock()+ if memory_state == "disabled":+ manager.controller.config.memory = SimpleNamespace(enabled=False)+ else:+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller.memory_runtime = SimpleNamespace()+ manager.controller._memory_implementation_error = None+ if memory_state == "missing":+ manager.controller.memory_runtime = None+ manager.controller._memory_implementation_error = MemoryImplementationUnavailableError("missing")+ elif memory_state == "incompatible":+ manager.controller.memory_runtime = None+ manager.controller._memory_implementation_error = MemoryImplementationIncompatibleError("incompatible")+ elif memory_state == "runtime_raising":+ manager.controller._memory_admission = Mock(side_effect=RuntimeError("runtime unavailable"))+ else:+ admission.admits.return_value = True+ manager.controller._memory_admission = Mock(return_value=admission)+ if memory_state == "disabled":+ manager.controller._memory_admission = Mock(side_effect=AssertionError("disabled Memory must not run"))- 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(),+ request = DeliveryRequest(+ session_id="ses_fsm",+ priority=priority,+ content="memory-independent delivery" if priority != "p0" else "replacement",)+ result = await manager.deliver(request, 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+ assert result.state == ("accepted" if priority == "p1" else "claimed")+ if priority == "p1":+ manager._steer.assert_awaited_once()+ manager.controller._memory_admission.assert_not_called()def test_persisted_start_attempt_reaches_dispatch_context(managers) -> None:@@ -2691,11 +2535,14 @@ def test_legacy_workbench_strict_author_keeps_memory_admission(managers) -> Nonedef test_durable_workbench_turn_restores_memory_admission_facts(managers,launch_path: str,+ monkeypatch,) -> None:from core.controller import Controllerfrom core.memory_cli_access import configure_memory_cli_accessmanager, _other, engine, _engine_b, _starts = managers+ # The Memory boundary reads the cached store; bind it to this fixture's engine.+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)manager.controller.config.memory = SimpleNamespace(enabled=True)classifications: list[bool | None] = []routing_users: list[str | None] = []