fred-runtime 4.3.0__tar.gz → 4.4.0__tar.gz

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-runtime
-Version: 4.3.0
+Version: 4.4.0
 Summary: Runtime adapters and infrastructure wiring for Fred v2 agents.
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0
@@ -12,8 +12,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Operating System :: OS Independent
 Requires-Python: <3.13,>=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: fred-core>=4.3.0
-Requires-Dist: fred-sdk[agents]>=4.3.0
+Requires-Dist: fred-core>=4.4.0
+Requires-Dist: fred-sdk[agents]>=4.4.0
 Requires-Dist: alembic>=1.18.4
 Requires-Dist: deepagents>=0.7.19
 Requires-Dist: httpx>=0.28.1

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/app/agent_app.py

@@ -43,6 +43,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import re
 import time
 from collections.abc import (
     AsyncGenerator,
@@ -64,8 +65,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
 from fred_core.common.config_loader import get_config
 from fred_core.common.fastapi_handlers import (
+    ACCOUNT_STATUS_UNAVAILABLE_CAUSE,
     DENIAL_CAUSE_HEADER,
-    STANDING_UNAVAILABLE_CAUSE,
 )
 from fred_core.common.fastapi_handlers import (
     register_exception_handlers as register_authorization_handlers,
@@ -79,7 +80,13 @@ from fred_core.logs.audit_log import emit_audit_log
 from fred_core.logs.log_setup import log_setup
 from fred_core.logs.log_store_factory import build_log_store
 from fred_core.security.backend_to_backend_auth import M2MBearerAuth
-from fred_core.security.delegation import AssertedUser, holds_caller_role
+from fred_core.security.delegation import (
+    AssertedUser,
+    DelegationGrant,
+    enforce_account_status,
+    holds_caller_role,
+)
+from fred_core.security.models import AuthorizationError
 from fred_core.security.rebac.rebac_engine import (
     ORGANIZATION_ID,
     OrganizationPermission,
@@ -251,6 +258,13 @@ from .observability_factory import bootstrap_observability
 
 logger = logging.getLogger(__name__)
 
+# Under delegation an audit event keeps codes only: free text can name a person.
+_BOUNDED_AUDIT_CODE = re.compile(r"[a-z_]+")
+
+
+def _is_bounded_audit_code(value: object) -> bool:
+    return isinstance(value, str) and _BOUNDED_AUDIT_CODE.fullmatch(value) is not None
+
 
 def _emit_audit_event(
     container: PodApplicationContext,
@@ -266,11 +280,12 @@ def _emit_audit_event(
     so every audit-worthy event across the runtime (this one, and tool-call
     invocations in ContextAwareTool) lands identically shaped.
     """
-    delegation = get_delegation_runtime()
-    if delegation is not None and delegation.enabled:
+    if delegation_enabled():
+        outcome, reason = fields.get("outcome"), fields.get("reason")
+        derived = "rejected" if level in {"warning", "error"} else "accepted"
         fields = {
-            "outcome": "rejected" if level in {"warning", "error"} else "accepted",
-            "reason": name,
+            "outcome": outcome if _is_bounded_audit_code(outcome) else derived,
+            "reason": reason if _is_bounded_audit_code(reason) else name,
         }
     event = cast(
         AuditEventRecord,
@@ -1752,12 +1767,13 @@ async def _resolve_agent_instance(
     response = await http_client.get(url, **request_kwargs)
     if (
         response.status_code == status.HTTP_503_SERVICE_UNAVAILABLE
-        and response.headers.get(DENIAL_CAUSE_HEADER) == STANDING_UNAVAILABLE_CAUSE
+        and response.headers.get(DENIAL_CAUSE_HEADER)
+        == ACCOUNT_STATUS_UNAVAILABLE_CAUSE
     ):
         raise HTTPException(
             status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Account standing could not be checked. Try again shortly.",
-            headers={DENIAL_CAUSE_HEADER: STANDING_UNAVAILABLE_CAUSE},
+            detail="Account status could not be checked. Try again shortly.",
+            headers={DENIAL_CAUSE_HEADER: ACCOUNT_STATUS_UNAVAILABLE_CAUSE},
         )
     if response.status_code == status.HTTP_404_NOT_FOUND:
         raise HTTPException(
@@ -1939,16 +1955,12 @@ async def _authorize_execution_or_raise(
                 ),
             )
         # A service identity runs as itself, identity-only, as with delegation off.
-        if delegated and not is_service_agent(authenticated_user):
+        team_id = request.effective_team_id()
+        if delegated and team_id and not is_service_agent(authenticated_user):
             rebac = get_runtime_context().config.rebac_engine
-            if rebac is None or not rebac.enabled:
-                raise HTTPException(status_code=503, detail="standing_unavailable")
-            await rebac.require_user_standing(authenticated_user.uid)
-            if request.effective_team_id():
+            if rebac is not None:
                 await rebac.check_user_team_permission_or_raise(
-                    authenticated_user,
-                    TeamPermission.CAN_USE_TEAM_AGENTS,
-                    request.effective_team_id(),
+                    authenticated_user, TeamPermission.CAN_USE_TEAM_AGENTS, team_id
                 )
         return
 
@@ -2000,9 +2012,19 @@ async def _authorize_execution_or_raise(
     # already authorizes the owner and denies everyone else — no special-
     # casing needed here (the bare "personal" alias also denies normally,
     # since no tuple is ever provisioned for that literal string).
-    await rebac.check_user_team_permission_or_raise(
-        authenticated_user, TeamPermission.CAN_USE_TEAM_AGENTS, team_id
-    )
+    try:
+        await rebac.check_user_team_permission_or_raise(
+            authenticated_user, TeamPermission.CAN_USE_TEAM_AGENTS, team_id
+        )
+    except AuthorizationError:
+        _emit_audit_event(
+            container,
+            "warning",
+            "rebac_denied",
+            outcome="rejected",
+            reason="permission_refused",
+        )
+        raise
     _emit_audit_event(
         container,
         "info",
@@ -2147,19 +2169,28 @@ def _admit_run_credentials(
         agent_instance_id or agent_id
     ):
         raise HTTPException(status_code=403, detail="delegation_target_mismatch")
-    record = delegation.records.admit(
-        RunRecord(
-            run_id=(
-                authenticated_user.run_id
-                if isinstance(authenticated_user, AssertedUser)
-                else str(uuid4())
-            ),
-            person_id=authenticated_user.uid,
-            agent_id=(agent_instance_id or agent_id or "unknown_agent"),
+    run_id = (
+        authenticated_user.run_id
+        if isinstance(authenticated_user, AssertedUser)
+        else str(uuid4())
+    )
+    agent = agent_instance_id or agent_id or "unknown_agent"
+    try:
+        # A receiver rejects a grant its rule refuses, so such a run would act
+        # for nobody; refuse it before a record exists.
+        DelegationGrant(person=authenticated_user.uid, run=run_id, agent=agent)
+    except ValidationError:
+        _emit_audit_event(
+            container,
+            "warning",
+            "delegation_unavailable",
+            outcome="rejected",
+            reason="invalid_parameters",
         )
+        raise HTTPException(status_code=403, detail="delegation_unavailable") from None
+    record = delegation.records.admit(
+        RunRecord(run_id=run_id, person_id=authenticated_user.uid, agent_id=agent)
     )
-    # Both halves of what a delegated call presents — the program that speaks and
-    # the person it speaks for — and neither of the credentials behind them.
     _emit_audit_event(
         container,
         "info",
@@ -5858,13 +5889,8 @@ def create_agent_app(
                 if security is not None
                 else None
             )
-            # The engine enforces standing in either direction; check its seed here.
-            if security is not None and security.delegation.in_use:
-                if rebac_engine is None:
-                    raise ValueError("Delegation requires a relationship engine.")
-                await rebac_engine.validate_standing_model()
-                if not await rebac_engine.is_standing_seed_ready():
-                    raise ValueError("Account standing is not ready.")
+            if rebac_engine is not None:
+                await enforce_account_status(rebac_engine)
             chat_factory = _build_chat_model_factory(config)
             if model_provider is not None and isinstance(
                 chat_factory, RoutedChatModelFactory

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/common/kf_base_client.py

@@ -19,8 +19,8 @@ from typing import Any, Dict, Optional, Protocol
 
 import httpx
 from fred_core.common.fastapi_handlers import (
+    ACCOUNT_STATUS_UNAVAILABLE_CAUSE,
     DENIAL_CAUSE_HEADER,
-    STANDING_UNAVAILABLE_CAUSE,
 )
 from fred_core.kpi.kpi_writer_structures import KPIActor
 from fred_core.security.backend_to_backend_auth import M2MBearerAuth
@@ -237,8 +237,8 @@ class KfBaseClient:
         """
         url = f"{self.base_url}{path}"
 
-        # One source for both halves of the call's identity: the header, and the
-        # grant parameters a delegated call carries beside it.
+        # The provider supplies the grant and, for a person, the header; a
+        # delegated call's bearer is set on each attempt by M2MBearerAuth.
         provider = self.credential_provider()
         override_token = kwargs.pop("access_token", None)
         credentials = await provider.credentials(override_token=override_token)
@@ -304,7 +304,8 @@ class KfBaseClient:
                 r.status_code in (401, 403)
                 or (
                     r.status_code == 503
-                    and r.headers.get(DENIAL_CAUSE_HEADER) == STANDING_UNAVAILABLE_CAUSE
+                    and r.headers.get(DENIAL_CAUSE_HEADER)
+                    == ACCOUNT_STATUS_UNAVAILABLE_CAUSE
                 )
             ):
                 # The receiver refused this run's authority after service-token

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/common/mcp_interceptors.py

@@ -22,8 +22,8 @@ from typing import AbstractSet, Awaitable, Callable
 
 import httpx
 from fred_core.common.fastapi_handlers import (
+    ACCOUNT_STATUS_UNAVAILABLE_CAUSE,
     DENIAL_CAUSE_HEADER,
-    STANDING_UNAVAILABLE_CAUSE,
 )
 from fred_sdk.contracts.runtime import unwrap_run_stop_error
 from langchain_mcp_adapters.interceptors import MCPToolCallRequest
@@ -47,9 +47,9 @@ AUTHORITY_REFUSED_STATUSES = (401, 403)
 class DelegatedAuthorityInterceptor:
     """Intercepts MCP tool calls made under delegation.
 
-    Two jobs: put a current workload bearer on every call, so a connection that
-    outlives one token keeps working; and end the run when a receiver refuses
-    this run's authority, rather than asking again with another credential.
+    Two jobs: refuse a tool call for a run that has ended; and end the run when
+    a receiver refuses this run's authority, rather than asking again with
+    another credential.
     """
 
     def __init__(
@@ -69,14 +69,9 @@ class DelegatedAuthorityInterceptor:
         if request.server_name not in self._delegated_server_ids:
             return await handler(request)
 
-        credentials = await self._provider.credentials()
-        headers = dict(request.headers or {})
-        if credentials.authorization:
-            headers["Authorization"] = credentials.authorization
-        call = request.override(headers=headers)
-
+        await self._provider.credentials()
         try:
-            result = await handler(call)
+            result = await handler(request)
             if (
                 isinstance(result, CallToolResult)
                 and result.isError
@@ -100,7 +95,7 @@ class DelegatedAuthorityInterceptor:
                 status == 503
                 and http_err is not None
                 and http_err.response.headers.get(DENIAL_CAUSE_HEADER)
-                == STANDING_UNAVAILABLE_CAUSE
+                == ACCOUNT_STATUS_UNAVAILABLE_CAUSE
             ):
                 raise
             logger.error(

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/common/mcp_utils.py

@@ -41,8 +41,8 @@ from typing import Dict, Final, List, Tuple
 
 import httpx
 from fred_core.common.fastapi_handlers import (
+    ACCOUNT_STATUS_UNAVAILABLE_CAUSE,
     DENIAL_CAUSE_HEADER,
-    STANDING_UNAVAILABLE_CAUSE,
 )
 from fred_core.security.backend_to_backend_auth import M2MBearerAuth
 from fred_core.security.delegation import scrub_grant_text
@@ -171,7 +171,7 @@ def _refusal_status(error: BaseException) -> int | None:
             if response.status_code in _REFUSAL_STATUSES or (
                 response.status_code == 503
                 and response.headers.get(DENIAL_CAUSE_HEADER)
-                == STANDING_UNAVAILABLE_CAUSE
+                == ACCOUNT_STATUS_UNAVAILABLE_CAUSE
             ):
                 return response.status_code
         pending.extend(
@@ -365,7 +365,7 @@ async def get_connected_mcp_client_for_agent(
 
     # --- Ask the provider ONCE for this connection attempt ---
     # With act_for_people off it answers with the person's bearer, on with the
-    # runtime's own workload bearer plus the grant this run acts under.
+    # grant this run acts under; M2MBearerAuth sets the workload bearer per request.
     needs_credentials = any(
         _normalize_auth_mode(server.auth_mode) != AUTH_MODE_NO_TOKEN
         for server in mcp_servers
@@ -376,18 +376,14 @@ async def get_connected_mcp_client_for_agent(
         call_credentials = OutboundCredentials()
     # --------------------------------------------------
 
-    if not call_credentials.authorization:
-        if confined:
-            logger.warning("[MCP] event=credential_resolution outcome=empty")
-        else:
-            logger.warning("MCP connect init: no outbound credential was supplied.")
+    if not call_credentials.authorization and not confined:
+        logger.warning("MCP connect init: no outbound credential was supplied.")
 
     auth_label = _mask_auth_value(call_credentials.authorization)
     # 🟢 LOG 5: Auth status
     if confined:
         logger.info(
-            "[MCP] event=credential_resolution outcome=completed auth=%s delegated=%s",
-            auth_label,
+            "[MCP] event=credential_resolution outcome=completed delegated=%s",
             call_credentials.delegated,
         )
     else:

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/common/outbound_credentials.py

@@ -54,7 +54,7 @@ class DelegationConfigurationError(RuntimeError):
 
 @dataclass(frozen=True)
 class OutboundCredentials:
-    """Authorization and grant parameters for one outbound request."""
+    """The person's bearer, or a delegated call's grant, for one outbound request."""
 
     authorization: str | None = None
     parameters: Mapping[str, str] = field(default_factory=dict)
@@ -166,8 +166,15 @@ def static_person_provider(
     return PersonCredentialProvider(_token, agent_id=agent_id)
 
 
+def _log_acquisition_failure(exc: Exception) -> None:
+    # Upstream errors can expose credentials; report only the type.
+    logger.error(
+        "The workload credential could not be obtained (%s).", type(exc).__name__
+    )
+
+
 class DelegatedCredentialProvider(OutboundCredentialProvider):
-    """Resolve the workload token and live run authority before each call."""
+    """Supply a live run's grant; M2MBearerAuth obtains the bearer per request."""
 
     delegated = True
 
@@ -200,25 +207,8 @@ class DelegatedCredentialProvider(OutboundCredentialProvider):
     async def credentials(
         self, *, override_token: str | None = None
     ) -> OutboundCredentials:
-        # Delegated calls cannot fall back to a caller-supplied person token.
-        record = self.record
-        if record.terminal:
-            raise DelegationUnavailableError()
-        scope = RunScope.current()
-        if scope is not None:
-            if scope.closed:
-                raise DelegationUnavailableError()
-            scope.raise_if_stopped()
-        token = await self._runtime.workload_token()
-        live_record = self.record
-        if live_record is not record or live_record.terminal:
-            raise DelegationUnavailableError()
-        if scope is not None:
-            if scope.closed:
-                raise DelegationUnavailableError()
-            scope.raise_if_stopped()
+        record = self._require_live_run()
         return OutboundCredentials(
-            authorization=f"Bearer {token}",
             parameters={
                 GRANT_PARAM_PERSON: record.person_id,
                 GRANT_PARAM_RUN: record.run_id,
@@ -234,7 +224,8 @@ class DelegatedCredentialProvider(OutboundCredentialProvider):
             raise DelegationUnavailableError()
         try:
             lease = await provider.get_token_lease()
-        except Exception:
+        except Exception as exc:
+            _log_acquisition_failure(exc)
             raise DelegationUnavailableError() from None
         if self._require_live_run() is not record:
             raise DelegationUnavailableError()
@@ -247,7 +238,8 @@ class DelegatedCredentialProvider(OutboundCredentialProvider):
             raise DelegationUnavailableError()
         try:
             replacement = await provider.refresh_rejected(lease)
-        except Exception:
+        except Exception as exc:
+            _log_acquisition_failure(exc)
             raise DelegationUnavailableError() from None
         if self._require_live_run() is not record:
             raise DelegationUnavailableError()
@@ -302,26 +294,6 @@ class DelegationRuntime:
                 "act_for_people is on but this deployment has no workload client."
             )
 
-    async def workload_token(self) -> str:
-        self.ensure_usable()
-        assert self._token_provider is not None  # ensure_usable proved it
-        try:
-            token = await self._token_provider.get_token()
-        except Exception as exc:
-            # Upstream errors can expose credentials; report only the type.
-            logger.error(
-                "The workload credential could not be obtained (%s).",
-                type(exc).__name__,
-            )
-            raise DelegationUnavailableError(
-                "The platform could not obtain its workload credential."
-            ) from None
-        if not token:
-            raise DelegationUnavailableError(
-                "The platform could not obtain its workload credential."
-            )
-        return token
-
     def provider_for(self, *, run_id: str, agent_id: str) -> OutboundCredentialProvider:
         return DelegatedCredentialProvider(
             runtime=self, run_id=run_id, agent_id=agent_id

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/integrations/v2_runtime/adapters.py

@@ -47,8 +47,8 @@ from urllib.parse import quote
 import httpx
 from fred_core.common import OwnerFilter
 from fred_core.common.fastapi_handlers import (
+    ACCOUNT_STATUS_UNAVAILABLE_CAUSE,
     DENIAL_CAUSE_HEADER,
-    STANDING_UNAVAILABLE_CAUSE,
 )
 from fred_core.common.team_id import is_personal_team_id
 from fred_core.kpi.base_kpi_writer import BaseKPIWriter
@@ -3111,14 +3111,12 @@ class TeamWikiAdapter(TeamWikiPort):
                 or (
                     response.status_code == 503
                     and response.headers.get(DENIAL_CAUSE_HEADER)
-                    == STANDING_UNAVAILABLE_CAUSE
+                    == ACCOUNT_STATUS_UNAVAILABLE_CAUSE
                 )
             ):
                 # Refused authority ends the run under this same identity.
                 raise AuthorityLostError()
             response.raise_for_status()
-        except AuthorityLostError:
-            raise
         except Exception as exc:
             raise _wrap_team_wiki_error(exc) from exc
         return response.json() if response.content else None

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime/runtime_support/tool_execution.py

@@ -84,20 +84,33 @@ class ToolExecution:
         # The service-agent flag is stamped by trusted admission, never tool args.
         if not user_id or is_service_agent:
             return
+        scope = RunScope.current()
+        delegated = scope is not None and scope.delegated_credentials
         try:
             if not team_id or is_personal_team_id(team_id):
-                scope = RunScope.current()
-                if scope is not None and scope.delegated_credentials:
-                    await rebac.require_user_standing(user_id)
+                if delegated:
+                    await rebac.require_active_account(user_id)
                 return
-            await rebac.check_permission_or_raise(
+            permission = rebac.check_permission_or_raise(
                 RebacReference(Resource.USER, user_id),
                 TeamPermission.CAN_USE_TEAM_AGENTS,
                 RebacReference(Resource.TEAM, team_id),
             )
+            if not delegated:
+                await permission
+                return
+            # Both are awaited to the end so an account status refusal wins over a
+            # permission check failure, whichever arrives first.
+            outcomes = await asyncio.gather(
+                rebac.require_active_account(user_id),
+                permission,
+                return_exceptions=True,
+            )
+            for outcome in outcomes:
+                if isinstance(outcome, BaseException):
+                    raise outcome
         except AuthorizationError:
-            scope = RunScope.current()
-            if scope is not None and scope.delegated_credentials:
+            if delegated:
                 raise AuthorityLostError() from None
             raise
 

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-runtime
-Version: 4.3.0
+Version: 4.4.0
 Summary: Runtime adapters and infrastructure wiring for Fred v2 agents.
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0
@@ -12,8 +12,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Operating System :: OS Independent
 Requires-Python: <3.13,>=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: fred-core>=4.3.0
-Requires-Dist: fred-sdk[agents]>=4.3.0
+Requires-Dist: fred-core>=4.4.0
+Requires-Dist: fred-sdk[agents]>=4.4.0
 Requires-Dist: alembic>=1.18.4
 Requires-Dist: deepagents>=0.7.19
 Requires-Dist: httpx>=0.28.1

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/fred_runtime.egg-info/requires.txt

@@ -1,5 +1,5 @@
-fred-core>=4.3.0
-fred-sdk[agents]>=4.3.0
+fred-core>=4.4.0
+fred-sdk[agents]>=4.4.0
 alembic>=1.18.4
 deepagents>=0.7.19
 httpx>=0.28.1

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "fred-runtime"
-version = "4.3.0"
+version = "4.4.0"
 description = "Runtime adapters and infrastructure wiring for Fred v2 agents."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"
 license = { text = "Apache-2.0" }
 authors = [{ name = "Thales", email = "noreply@thalesgroup.com" }]
 dependencies = [
-  "fred-core>=4.3.0",
-  "fred-sdk[agents]>=4.3.0",
+  "fred-core>=4.4.0",
+  "fred-sdk[agents]>=4.4.0",
   "alembic>=1.18.4",
   "deepagents>=0.7.19",
   "httpx>=0.28.1",

{fred_runtime-4.3.0 → fred_runtime-4.4.0}/tests/test_agent_app.py

@@ -421,8 +421,8 @@ def _secured_pod(
     tmp_path,
     *,
     caller_client_id: str,
-    enforces_standing: bool = True,
-    standing_seed_ready: bool = True,
+    requires_active_accounts: bool = True,
+    account_status_model_error: Exception | None = None,
     accept_delegated_calls: bool = True,
     **token: object,
 ):
@@ -451,11 +451,12 @@ def _secured_pod(
         agent_app_module,
         "rebac_factory",
         lambda *args, **kwargs: SimpleNamespace(
-            enforces_standing=enforces_standing,
+            requires_active_accounts=requires_active_accounts,
             enabled=True,
-            validate_standing_model=AsyncMock(),
-            is_standing_seed_ready=AsyncMock(return_value=standing_seed_ready),
-            require_user_standing=AsyncMock(),
+            validate_account_status_model=AsyncMock(
+                side_effect=account_status_model_error
+            ),
+            require_active_account=AsyncMock(),
         ),
     )
     app = create_agent_app(
@@ -507,8 +508,9 @@ def test_a_role_holder_whose_token_is_not_addressed_to_delegation_is_refused(
 def test_a_service_bearer_without_the_caller_role_runs_as_itself_under_delegation(
     monkeypatch, tmp_path, _pod_inbound_security
 ) -> None:
-    """The evaluator names no person: it runs on its own bearer, and a direct
-    target skips the person's standing and team checks, as with delegation off."""
+    """The evaluator names no person: it runs on its own bearer. Its request's
+    account status check passes, and a direct target skips the team check, as with
+    delegation off."""
     app, delegation = _secured_pod(
         monkeypatch, tmp_path, caller_client_id="caller-1", accept_delegated_calls=False
     )
@@ -516,7 +518,7 @@ def test_a_service_bearer_without_the_caller_role_runs_as_itself_under_delegatio
     with TestClient(app) as client:
         engine = get_runtime_context().config.rebac_engine
         assert engine is not None
-        engine.require_user_standing = AsyncMock(side_effect=AssertionError)
+        engine.require_active_account = AsyncMock()
         engine.check_user_team_permission_or_raise = AsyncMock(
             side_effect=AssertionError
         )
@@ -538,6 +540,7 @@ def test_a_service_bearer_without_the_caller_role_runs_as_itself_under_delegatio
         ]
 
     assert response.status_code == 200
+    engine.require_active_account.assert_awaited_once_with("workload-caller")
     assert admitted == []
     assert len(delegation.records) == 0
 
@@ -6677,19 +6680,51 @@ async def test_authorize_and_resolve_times_pod_authz_and_runtime_binding_phases(
 @pytest.mark.parametrize(
     "accept_delegated_calls", [False, True], ids=["acting-only", "also-accepting"]
 )
-def test_delegation_refuses_to_start_before_standing_is_ready(
+def test_delegation_startup_validates_the_account_status_model_and_writes_nothing(
+    monkeypatch, tmp_path, _pod_inbound_security, accept_delegated_calls: bool
+) -> None:
+    """Every person without a suspension has an active account, so startup only
+    reads the model: the engine exposes no write, and nothing else is awaited."""
+    app, _ = _secured_pod(
+        monkeypatch,
+        tmp_path,
+        caller_client_id="caller-1",
+        accept_delegated_calls=accept_delegated_calls,
+    )
+
+    with TestClient(app):
+        engine = get_runtime_context().config.rebac_engine
+        assert engine is not None
+        awaited = {
+            name
+            for name, value in vars(engine).items()
+            if isinstance(value, AsyncMock) and value.await_count
+        }
+
+    assert awaited == {"validate_account_status_model"}
+    engine.validate_account_status_model.assert_awaited_once_with()
+
+
+@pytest.mark.parametrize(
+    "accept_delegated_calls", [False, True], ids=["acting-only", "also-accepting"]
+)
+def test_delegation_refuses_to_start_on_a_model_without_the_suspended_relation(
     monkeypatch, tmp_path, _pod_inbound_security, accept_delegated_calls: bool
 ) -> None:
-    """Before default standing is granted the store answers "not active" for
-    everyone, which would refuse every person rather than enforce anything."""
+    """A model that cannot record a suspension cannot refuse anyone, so the pod
+    stops before serving instead of admitting every person."""
     app, _ = _secured_pod(
         monkeypatch,
         tmp_path,
         caller_client_id="caller-1",
-        standing_seed_ready=False,
+        account_status_model_error=RuntimeError(
+            "Account status authorization model is not available."
+        ),
         accept_delegated_calls=accept_delegated_calls,
     )
 
-    with pytest.raises(ValueError, match="not ready"):
+    with pytest.raises(
+        RuntimeError, match="^Account status authorization model is not available.$"
+    ):
         with TestClient(app):
             pass