Skip to content

armgit / avibe

Public Imported from GitHub
0

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.

fix(memory): take the Memory authority gate off the delivery path (#2109)

rkrkrkk613f76ab7e6b
diff --git a/core/controller.py b/core/controller.py
index f0d134a50..aa30c900f 100644
--- a/core/controller.py
+++ b/core/controller.py
@@ -3499,6 +3499,24 @@ class Controller:
return None
session_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 None
if (
getattr(self, "_memory_implementation_error", None) is not None
and isinstance(implementation_sessions, set)
diff --git a/core/session_turns.py b/core/session_turns.py
index 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_specs
diff --git a/docs/plans/2026-09-22-memory-zero-impact-delivery.md b/docs/plans/2026-09-22-memory-zero-impact-delivery.md
new file mode 100644
index 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.py
index 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 = None
return 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 None
diff --git a/tests/test_memory_delegated_lifecycle.py b/tests/test_memory_delegated_lifecycle.py
index 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, m
asyncio.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)) == scope
else:
- 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, monkeypatch
assert 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.py
index 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.py
index 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 = True
diff --git a/tests/test_session_delivery_fsm.py b/tests/test_session_delivery_fsm.py
index d66d763be..8c9548875 100644
--- a/tests/test_session_delivery_fsm.py
+++ b/tests/test_session_delivery_fsm.py
@@ -4,7 +4,6 @@ import asyncio
import gc
import json
import sqlite3
-import sys
import threading
from concurrent.futures import ThreadPoolExecutor
from 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 None
manager._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) -> None
def test_durable_workbench_turn_restores_memory_admission_facts(
managers,
launch_path: str,
+ monkeypatch,
) -> None:
from core.controller import Controller
from core.memory_cli_access import configure_memory_cli_access
manager, _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] = []