feat(tenancy): establish cloud isolation foundations

tests/unit_tests/provider/test_mcp_box_integration.py

@@ -154,6 +154,7 @@ def mcp_module():
 def _make_ap():
     ap = Mock()
     ap.logger = Mock()
+    ap.instance_config = SimpleNamespace(data={'mcp': {'stdio': {'enabled': True}}})
     ap.workspace_service = Mock()
     ap.workspace_service.get_execution_binding = AsyncMock(
         return_value=SimpleNamespace(
@@ -791,6 +792,31 @@ class TestBoxConfigParsing:
         assert s.box_config.host_path_mode == 'ro'
 
 
+@pytest.mark.asyncio
+async def test_stdio_instance_gate_runs_before_box_transport(mcp_module):
+    ap = _make_ap()
+    ap.instance_config.data['mcp']['stdio']['enabled'] = False
+    ap.box_service.available = True
+    session = _make_session(
+        mcp_module,
+        {
+            'name': 'blocked',
+            'uuid': 'blocked-uuid',
+            'mode': 'stdio',
+            'command': 'python',
+            'args': [],
+            'env': {},
+        },
+        ap=ap,
+    )
+    session._box_stdio_runtime.initialize = AsyncMock()
+
+    with pytest.raises(RuntimeError, match='disabled by instance policy'):
+        await session._init_stdio_python_server()
+
+    session._box_stdio_runtime.initialize.assert_not_awaited()
+
+
 @pytest.mark.asyncio
 async def test_init_box_stdio_server_stages_host_path_in_shared_workspace(mcp_module, tmp_path):
     mcp_stdio_module = sys.modules['langbot.pkg.provider.tools.loaders.mcp_stdio']

tests/unit_tests/provider/test_mcp_stdio_policy.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from langbot.pkg.provider.tools.loaders.mcp_policy import (
+    MCPStdioDisabledError,
+    require_stdio_mcp_enabled,
+    stdio_mcp_enabled,
+)
+from langbot.pkg.provider.tools.loaders.mcp import MCPLoader
+
+
+def _app(config: dict) -> SimpleNamespace:
+    return SimpleNamespace(instance_config=SimpleNamespace(data=config))
+
+
+def test_oss_default_remains_enabled_when_key_is_absent():
+    assert stdio_mcp_enabled(_app({})) is True
+
+
+@pytest.mark.parametrize(
+    'value',
+    [False, 'false', 0, None, {}, []],
+)
+def test_disabled_or_invalid_values_fail_closed(value):
+    ap = _app({'mcp': {'stdio': {'enabled': value}}})
+
+    assert stdio_mcp_enabled(ap) is False
+    with pytest.raises(MCPStdioDisabledError, match='disabled by instance policy'):
+        require_stdio_mcp_enabled(ap, {'mode': 'stdio'})
+
+
+def test_remote_transport_is_independent_of_stdio_gate():
+    ap = _app({'mcp': {'stdio': {'enabled': False}}})
+
+    require_stdio_mcp_enabled(ap, {'mode': 'remote'})
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_retains_but_does_not_launch_disabled_stdio_rows():
+    server = SimpleNamespace(uuid='server-a', workspace_uuid='workspace-a')
+    result = Mock()
+    result.all.return_value = [server]
+    ap = _app({'mcp': {'stdio': {'enabled': False}}})
+    ap.logger = Mock()
+    ap.persistence_mgr = SimpleNamespace(
+        execute_async=AsyncMock(return_value=result),
+        serialize_model=Mock(
+            return_value={
+                'uuid': 'server-a',
+                'workspace_uuid': 'workspace-a',
+                'name': 'local',
+                'mode': 'stdio',
+                'enable': True,
+                'extra_args': {},
+            }
+        ),
+    )
+    ap.workspace_service = SimpleNamespace(get_execution_binding=AsyncMock())
+    loader = MCPLoader(ap)
+    loader.host_mcp_server = AsyncMock()
+
+    await loader.load_mcp_servers_from_db()
+
+    loader.host_mcp_server.assert_not_awaited()
+    ap.workspace_service.get_execution_binding.assert_not_awaited()
+    assert loader.sessions == {}