multiagentos 0.4.0__py3-none-any.whl

multiagentos-0.4.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: multiagentos
+Version: 0.4.0
+Summary: Local-first, GitHub-native multi-agent orchestration foundation for VYRELON
+Requires-Python: >=3.10
+Provides-Extra: chatgpt
+Requires-Dist: openai>=1.0; extra == "chatgpt"

multiagentos-0.4.0.dist-info/RECORD

@@ -0,0 +1,122 @@
+agents/__init__.py,sha256=y8HsCN8YhVOJqxV1MtJouTbIsFHnAE5E7rL0YMrrJDQ,38
+agents/catalog.py,sha256=lZAD7k5BNZaUjdCfNQhL8K-6AzU-yK7xPgWdLlySdzk,2432
+agents/registry.py,sha256=lHnGWejM5V_hHk_duuFEGX4TiTkhEOxYwWqZPQzMwPI,341
+core/__init__.py,sha256=DNVaqbDfMDiMSzjRTCnGlp9K-GeL8rDFtGE38LpkKkw,2422
+core/artifacts.py,sha256=x8UEkQBSNwaEsW7wqv3vya7A_JiJ2LD8TvC0SkzAP08,1576
+core/chat_agent_bridge.py,sha256=4pwaF-zRWpt42JaP5UGWKwvEj9OHI3FKSaM82-lwwoI,10791
+core/chat_agent_registry.py,sha256=AXOMJERyrGroXEo6FPvVNB75rQEAc3CiLTlH05MRGn8,1933
+core/chat_agent_router.py,sha256=ta45juNjxQdE4uCDDrrmsPRItZFaSpv9eO8pnv4c-A8,2872
+core/chat_session.py,sha256=iM-4iYIl6gGXDQqn_rnRYuPqb3-dsr5zHnuB6W65Z1c,2100
+core/delegation.py,sha256=ZDynxkaLhcQ5AqzMdys55jxMeJmZxzFbo7_ddEL2qMs,1029
+core/handoff.py,sha256=xijpkuYsdExvgQI8gXaVpTD80Oyn9x2MlfZG2SFrwCs,2573
+core/lifecycle.py,sha256=rTmvKidCX4YS9TR9lKwWrM7TY29oMCHRL7bpnP8YOsU,3624
+core/multi_agent_workflow.py,sha256=_n2FFsIq_U5AAt1oBx2Xn7DjUJdpiy6P7qM-QB6dF6w,28509
+core/orchestrator.py,sha256=Y1_TSlGMQ2EX75e7VVC6rfXjVp3NWuZbHdu59seLch0,1656
+core/planning.py,sha256=SLSwiMl2pU7Y2b-JxOvzI72sF5OpbeG67aGGEqJwyZU,797
+core/registry.py,sha256=_YPS8PvSUmueTvXOaECzFB27Lvx4ERhBX7oDWcRaurw,1489
+core/routing.py,sha256=8muE1DDrUfH-nQhLGENKHHVKpbrk6yX-bk_5lpk4j7s,7357
+core/state.py,sha256=HUaBrmQOSwrzfNZxPPogQzDXhcx_3DpCUvcDAvNq9hQ,5567
+core/contracts/__init__.py,sha256=AW61P8Bon06eUtByLe7VBpAaiBhJnytopx-Xy0kPiEY,1260
+core/contracts/agent.py,sha256=YfzN1KaZLVLuo76my18Nb4FhJzHkvPNHJLtWAsKcRN4,574
+core/contracts/ai.py,sha256=5Z3QLt9kDOaMd0WcrKYl_7MzhiZg-8c2KEjEoxz7-o8,607
+core/contracts/capability.py,sha256=jd1oTxaRuvaKyNDjibx2cMb-4h7TymAd76-JC6OSaMA,1194
+core/contracts/chat_agent.py,sha256=1BhxrZuxxOH3ZInN-yK5yMY648CtFXX5NDjMDIvVIL8,1034
+core/contracts/checkpoint.py,sha256=wIGOtUVtjex13o6RUjaixbngdplm_lEY3x0gbeC66KE,3017
+core/contracts/discovery.py,sha256=xJawPFQON_ynjAGxDg9LuYTHR_73e48yw1TD9_CaS1U,804
+core/contracts/execution.py,sha256=evMJ1Cv2LApE4wQdV7vEs2t4vpopvQnbnAx3umtk3M0,696
+core/contracts/github.py,sha256=vJ5lgGrzf8_oelv2dVuwPehtpb1tYYpSRCI91j4AFmE,1977
+core/contracts/handoff.py,sha256=Y2tpas2YXsq0tsdLiip_Me9nlitk7DfniB9Fc9-b6f4,1428
+core/contracts/health.py,sha256=CVF_L4ukFq8HxZdTmzvlSDOFwplm5X-mhRXQMxc7qho,7847
+core/contracts/human_review.py,sha256=f8-QrzQY7gySPKuNY2LO8GngdfxEg0dU9jabOPezbxg,625
+core/contracts/ide.py,sha256=rjNCq-AfYRAtmYZ4NLGtc1nmWoWZNxHPXwo8isveIvQ,2901
+core/contracts/mcp.py,sha256=YG5SoRWQgyPrS00vvrwjiAOEsBWQ76kJjD7fYOmA17g,2874
+core/contracts/model_runtime.py,sha256=38LA5E3WJLcGRBLRnG3eousAGIeOTW8F1X3axJrIRoI,583
+core/contracts/planning.py,sha256=f3Y9lxOa-fm0uUY5wf8x2e-_YD8eOUw02sG7HyN_wKI,606
+core/contracts/profile.py,sha256=ToTYhSYo522chlofTbdNQh7o24ED3ktFTnhHuAjwH6g,1837
+core/contracts/quota.py,sha256=wFSv8p8meH-OomfM7A1iRGXkJpb58TvBDWuyFf8nTXk,1972
+core/contracts/repository.py,sha256=WxfszMGN-UhVEAVdu5DWXOEx0xizuauVB5DHl0Stdl4,735
+core/contracts/resume.py,sha256=1Msuel7LFFZICYN6dzZ-fgabrUUxyA8svb9j6uy7WCQ,2051
+core/contracts/runtime.py,sha256=3wvtE1UgoN0m5fgaiWc0jokNsh8OQ7NhrYm2fhKVdQ0,454
+core/contracts/vyrelon_runtime.py,sha256=PVVthOaRQFhqcKI8FI72u0tVCYRg2KG_KtmJgKhu_Pg,3150
+core/contracts/work_unit.py,sha256=OYV1uaz8OL0PwF66aVzGExBE_FGN1U8_fkfkRbQUhk4,2176
+installer/__init__.py,sha256=QX7TH_bKx3EjYlWVCiULi9azBmusF8PtSXAdJu2fApQ,33
+installer/init.py,sha256=Cv49irDMBkC7x3VQt4PXLa1YkozPaGRP69i1LmCx_1Q,2395
+integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+integrations/github/__init__.py,sha256=nwgfGd3sLQqBJLen49mToxQ7_ShXPT-nFS0s9mO7fHo,76
+integrations/github/gateway.py,sha256=VRIXB0x9tzbqyfCWvnKFfFCBfAzvRtRWqArYUoGtQ10,5849
+integrations/openai/__init__.py,sha256=1W9xUQyjzOqA9Kj9y7zCbLXi6Ymhspnq5Hl4pmbhRlI,56
+integrations/openai/chat_agent.py,sha256=9APx0HTlsyOGNCmUB7iP2dD1qhd___DZRvNjon_2llU,4912
+multiagentos/__init__.py,sha256=-WldAiz_IVL68ANxkJ4wXNyiuUknWJdJ1oHT9cJgNo8,41
+multiagentos/cli.py,sha256=QoiNQkINCGj4uCfte2DK12zHwjxXYput_W4DoJ7fUwU,31059
+profiles/__init__.py,sha256=EnaT_9gNjw8eLRK7O7uDLsa9IYa-cYOTsr4L7neLBBQ,48
+profiles/common.py,sha256=A6J4go0KKfAhnJTTavPJ9GN3PxeoD88XrrldO3B-qI0,190
+profiles/detector.py,sha256=nF6SM4TN_ILyKpO38i8rtJsw7ZniVRY6AZEyElBoWVg,2755
+profiles/registry.py,sha256=IqPx6XyMkKcWXSpS9Htty4qnrlOBxHeIczhdrH-kRGg,1519
+profiles/resolver.py,sha256=QrUeBvr9svCtxUkKZXh5hPygkhP89QlqmHXdh-aOn-M,2269
+runtime/__init__.py,sha256=MuEw9LO8UJqQND0iztNb6sj7NHpGZgRDMTwPBUa0N7s,112
+runtime/builtin_tools.py,sha256=PRPB2RZujqRfWLMmM63us1Zmvs8E6A356SMwm2tRHYQ,3335
+runtime/capability.py,sha256=e6Y7fOg0wFhAeS6T50S_bWiMTYoNuwZ0q52y5FIvpn0,5543
+runtime/chat_adapter_registry.py,sha256=O_zjBaA_KEXC79SmLiU4tIis2jNny-uzW2nCWc-UGNw,1385
+runtime/chat_config.py,sha256=gD07_5B3czQ044M1J4cM9ECQ3LAcsQiMci6osGc08T4,1824
+runtime/chat_execution.py,sha256=9MjzXT47MROMCZ3ftt4OuuzTVenY4zTg2BhpEoAPd2E,1778
+runtime/discovery.py,sha256=0oATBN5jLG_5Dc2o6WF3rzWGz310szv0iIVjeo5EQO8,14274
+runtime/execution_config.py,sha256=rfz5KaHLozmhw9c6IfPUavUELAWEo3xrpRO6DX78tpo,2179
+runtime/execution_registry.py,sha256=bUeG0UzQRvJyK0jd0aGnMfuQEGUnzCVgpHaSdnAI84M,1425
+runtime/git.py,sha256=ZmBtpetBXLouwat-3KySH_ljTOjA58ruo8kHgLEAl2A,3275
+runtime/github.py,sha256=YiPPfPFBiDwf30pyL-lVS3vqDOopjVWzkS8Sr3aD71M,2394
+runtime/github_probe.py,sha256=LR3iSGVvf0SZ3COitA9IhpbXRKkBHEoevfK0tKW8vMo,656
+runtime/health.py,sha256=xiH9Kay_wDYPBh2ZWWcbmbxvjzOYPFYLuGsb-rE1DYs,263
+runtime/model_control.py,sha256=XX7fRAY1cNBO5MJlBklgOw0polTqTW3G8wV0TGPT13E,5027
+runtime/multi_agent.py,sha256=ut-MGFdZEPNP-a0GbxGWGdl_tM934e9ab_rOLS6hDIk,5471
+runtime/policy.py,sha256=zziUs3sIZoNg7ymAsUdNT1zkLb6Omcc3RT-Kv0gtld4,931
+runtime/process.py,sha256=lyvvWk-x6ZGxEWroMW2CBbQgvnkU9dCkDKZnorVoXsI,1051
+runtime/quota.py,sha256=tepzRRathFlR47vUtkCIPvEj2gz-3VRfaN9vw_PA8cg,9863
+runtime/repository.py,sha256=s7LeenkxPLpKWa-G-TjXCCBAes0cLqkJpmnJmw4X78o,4469
+runtime/repository_tools.py,sha256=nJwbDJICo8Oe8CzjBEPXwB0aGVjvAgO8KNS-rbJYDYI,3898
+runtime/status.py,sha256=I1hR5k6apgb7ScUps8YpgZ_tsX7wZ-wIGCPeBUFO-PY,3117
+runtime/tool_calling.py,sha256=j87XkqCYmGzyaIdCWvKZEvCTDH0HYS5b212oNGVyJjM,7645
+runtime/validation.py,sha256=eVHeCErxYPVX8I7IBdKuRx0DelBK94CldvpuPsdGxC0,3613
+runtime/vyrelon.py,sha256=OXV-cxDFKF088QHQM8LoyUf7XWvy9aKEJ17d3Y0GSpc,66439
+runtime/agent/__init__.py,sha256=sXO_vqwo7w0lJ0NmhQ3CxaX_HA3byyBoDDRIYHphWRo,30
+runtime/agent/ide.py,sha256=ha2XR0XtSsaC_AItBG9gpg2mQ1knPNgm1dXuFq1JGm8,2772
+runtime/agent/model.py,sha256=ba20cT1dLVYWwtX6nVxupGf2IviFNbh3HQt2S0aatWE,9846
+runtime/agent/model_backed.py,sha256=vHYJilKiyv6nkladkwKEwS9IR5Z9cLzdOY9wWXjjf5E,1813
+runtime/agent/process.py,sha256=D791ZlAqWu6b_tRQswn2DbyKhu4-VXOffir_maVmx58,746
+runtime/config/__init__.py,sha256=cFuQW5pF5LwvfkXMcpWcEeVLtHxMzm0serM-oNXlFLg,37
+runtime/config/loader.py,sha256=UYPTBap_lzXhAcApCQH7nEG9IFGFbY7BEE_kpMxYrPY,2395
+runtime/ide/__init__.py,sha256=9TfNq6Oe4UoowMGEkv0zlrlEyhu8XQUw6wnZ2-cu34w,171
+runtime/ide/bridge.py,sha256=fQ5k2AuPtpdWGEF14KcPxpT91lwMjzEPJOJsuTz3neQ,7921
+runtime/ide/registry.py,sha256=Vz14Nnx2K945Ei3QfTCX2XvJTCzwgOiojVM74y_AEmI,720
+runtime/ide/runtime.py,sha256=-K_oag89Veq7s-I6bueoe6OUvYzDRUcDqjOStf0OYic,1340
+runtime/local/__init__.py,sha256=eCzuXSAUy6_IbuXq3SqiSBHgKARv-T8SZBUuZXoowjo,542
+runtime/local/filesystem.py,sha256=KWLmVtC9y5fGsd0CpkHzXh00FiNuI7MreEs1t-EbxnQ,2138
+runtime/local/patch.py,sha256=3buicbQiygh_M_DKmdyK8o1ucrmQnTr9n3VyaG0g-GY,2826
+runtime/local/path_security.py,sha256=PKDfCy48pt3GN_gysHDO_T4_l-ygUsRNAo0BmVhWzyk,1160
+runtime/local/permissions.py,sha256=s4OC2DQqq71pWX5JqoRbdcLOkVl6pDKreTTRA81NM-w,665
+runtime/local/process.py,sha256=bOkOfsiYaTfI86d9YclNY1LkTACoZCsa63LHrbK3U-w,1933
+runtime/local/shell.py,sha256=0bT-7oc2MKY0M1qY-bM9bSMKZ6ryfD9VbJxT6T6z2lo,2990
+runtime/mcp/__init__.py,sha256=Q-LvSM1AGNW6uGq8B4b6QEEGCnAOInS_gS-zQmQaCD4,359
+runtime/mcp/client.py,sha256=chJyEbuEgaPaD3jEPI6LyECIEm4rqv9l27-cPQwAdXU,6912
+runtime/mcp/config.py,sha256=CqDFZ4bxUI1XzOPyXuwsIAs7i8r5YGr9Ebcvww_Y0QU,1759
+runtime/mcp/policy.py,sha256=3I2HQ0JO1BUXVOVh2Izug5feD7zjSQzFMGdutRb-1EI,2962
+runtime/mcp/proxy.py,sha256=wfG2xx23PitQIq7izc1IDV3zNN6L5lKvCtzbhl0lNoE,1662
+runtime/mcp/server.py,sha256=uYKAKrDHwaluMAWEocBeGi4nDxd4oY6i_7b55n9jkJM,5012
+runtime/mcp/session.py,sha256=-yVuLPSSTfStYY8n2Ounc93D4qacnafXF_nQq270Rfk,835
+runtime/model/__init__.py,sha256=xZK9YeuhXqbU2TH3ek36COu9tBARdyMYy5Psqg4CUO4,185
+runtime/model/ai_runtime.py,sha256=Z3M5SL-KZcmlOPGLBf3c3TEdPd1GjOJvV7Lq0U_P5zo,5151
+runtime/model/cli.py,sha256=2bgUBgdhVIz7lPv2uuBIsXLeiZhMsbF9ZruHlFjGP7o,1608
+runtime/model/config.py,sha256=7yFBv3LW5rYVlj55gPqm1VQHBVeLGzYp-bElY4ICHsA,3391
+runtime/model/credentials.py,sha256=PA6HRSx91qNzrNw1XXJz7WllUR8NGQSbm0q3Vvck5EE,1255
+runtime/model/factory.py,sha256=fYylUKaGlpMgTVxv1sIHQrEWRZYDWnqbJcps17dHlsE,3201
+runtime/model/http.py,sha256=UX2V6dyM4Yi1ukVlZkuerORpb4cMPNh9dCdP3ncG8OI,2933
+runtime/model/invoker.py,sha256=k4wFSsYAeTCapwHOf1euDfsHrulD_q0n7Nx9t72RVBY,679
+runtime/model/materializer.py,sha256=uwBwOEv11iT704pPk5jzM8TQB1BOs6Nl-o0Uuy-DVBY,4084
+runtime/model/native.py,sha256=54KqxPt9TH6T4KHb_TinsJTjHxlqOOfFT6YCZtPsQOM,14147
+runtime/model/providers.py,sha256=7mWTL8tx4oqeA4vmyB9YFxB1n31qCBvIfHCPWk7X8Io,2050
+runtime/model/registry.py,sha256=ZlLxKhEDtiNh03weL0cAU4fh82TYC64602rE-03dmlM,947
+runtime/model/runtime_loader.py,sha256=aeK3MISBTBSN3pmKCzh_wTqFe6_zCwLAZCD2Qvu_QkA,1706
+multiagentos-0.4.0.dist-info/METADATA,sha256=XWf5m0oIs42U8mRtF0SKf0Guxhqd5oFHdhtjm7_Ux5g,236
+multiagentos-0.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+multiagentos-0.4.0.dist-info/entry_points.txt,sha256=nm1yOCYxb6I5ACZHfl6gUOqrJuy7cAWhBKtwTaUEGK4,55
+multiagentos-0.4.0.dist-info/top_level.txt,sha256=4sxE8X-XOTUs2_SEwTG6LNfrwmqT1DbqqhXylXQLsNg,65
+multiagentos-0.4.0.dist-info/RECORD,,

multiagentos-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

multiagentos-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+multiagentos = multiagentos.cli:main

multiagentos-0.4.0.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+agents
+core
+installer
+integrations
+multiagentos
+profiles
+runtime

profiles/__init__.py

@@ -0,0 +1 @@
+"""Technology profiles supported by VYRELON."""

profiles/common.py

@@ -0,0 +1,11 @@
+"""Common role definitions shared by technology profiles."""
+
+COMMON_ROLES = (
+    "planner",
+    "researcher",
+    "editor",
+    "executor",
+    "tester",
+    "debugger",
+    "reviewer",
+)

profiles/detector.py

@@ -0,0 +1,67 @@
+"""Project profile detection based on repository evidence."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core.contracts.profile import DetectionResult, ProfileSpec
+from profiles.registry import ProfileRegistry
+
+
+_IGNORED_DIRS = {".git", "node_modules", "Pods", ".gradle", "build", "dist", "venv", ".venv"}
+
+
+class ProfileDetector:
+    def __init__(self, registry: ProfileRegistry | None = None) -> None:
+        self.registry = registry or ProfileRegistry()
+
+    def detect(self, project_root: Path) -> tuple[DetectionResult, ...]:
+        results = []
+        for profile in self.registry.list():
+            evidence = self._evidence(project_root, profile)
+            if evidence:
+                confidence = min(
+                    1.0,
+                    len(evidence) / max(1, len(profile.detect_files) + len(profile.detect_markers)),
+                )
+                results.append(DetectionResult(profile.id, confidence, tuple(evidence)))
+        return tuple(sorted(results, key=lambda result: (-result.confidence, result.profile_id)))
+
+    def _evidence(self, root: Path, profile: ProfileSpec) -> list[str]:
+        evidence = [name for name in profile.detect_files if (root / name).exists()]
+
+        package = root / "package.json"
+        if package.exists() and "react-native" in profile.detect_markers:
+            try:
+                data = json.loads(package.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                data = {}
+            dependencies = {
+                **data.get("dependencies", {}),
+                **data.get("devDependencies", {}),
+            }
+            if "react-native" in dependencies:
+                evidence.append("package.json:react-native")
+
+        for marker in profile.detect_markers:
+            if marker.startswith("."):
+                if any(root.glob(f"*{marker}")):
+                    evidence.append(marker)
+            elif self._contains_marker(root, marker):
+                evidence.append(marker)
+
+        return list(dict.fromkeys(evidence))
+
+    def _contains_marker(self, root: Path, marker: str) -> bool:
+        candidate_names = {"settings.gradle", "settings.gradle.kts", "build.gradle", "build.gradle.kts", "Package.swift"}
+        for path in root.rglob("*"):
+            if any(part in _IGNORED_DIRS for part in path.parts):
+                continue
+            if path.is_file() and (path.name in candidate_names or path.suffix in {".gradle", ".kts", ".swift"}):
+                try:
+                    if marker in path.read_text(encoding="utf-8", errors="ignore")[:20000]:
+                        return True
+                except OSError:
+                    continue
+        return False

profiles/registry.py

@@ -0,0 +1,46 @@
+"""Built-in VYRELON technology profile registry."""
+
+from core.contracts.profile import ProfileSpec
+from profiles.common import COMMON_ROLES
+
+
+PROFILES = (
+    ProfileSpec(
+        id="react-native",
+        display_name="React Native",
+        detect_files=frozenset({"package.json"}),
+        detect_markers=frozenset({"react-native"}),
+        roles=COMMON_ROLES + (
+            "architect", "developer", "ui", "navigation", "state-management",
+        ),
+    ),
+    ProfileSpec(
+        id="android-native",
+        display_name="Android Native",
+        detect_files=frozenset({"settings.gradle", "settings.gradle.kts"}),
+        detect_markers=frozenset({"com.android.application", "com.android.library"}),
+        roles=COMMON_ROLES + (
+            "android-architect", "kotlin-developer", "jetpack-compose", "gradle",
+        ),
+    ),
+    ProfileSpec(
+        id="ios-native",
+        display_name="iOS Native",
+        detect_files=frozenset({"Package.swift"}),
+        detect_markers=frozenset({".xcodeproj", ".xcworkspace"}),
+        roles=COMMON_ROLES + (
+            "ios-architect", "swift-developer", "swiftui", "xcode",
+        ),
+    ),
+)
+
+
+class ProfileRegistry:
+    def __init__(self, profiles: tuple[ProfileSpec, ...] = PROFILES) -> None:
+        self._profiles = {profile.id: profile for profile in profiles}
+
+    def get(self, profile_id: str) -> ProfileSpec:
+        return self._profiles[profile_id]
+
+    def list(self) -> tuple[ProfileSpec, ...]:
+        return tuple(self._profiles.values())

profiles/resolver.py

@@ -0,0 +1,63 @@
+"""Resolve technology detections into stable VYRELON project and agent profiles."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from agents.catalog import build_agent_catalog
+from core.contracts.profile import AgentProfile, DetectionResult, ProjectProfile
+from profiles.detector import ProfileDetector
+
+
+class ProfileResolver:
+    """Build a deterministic ProjectProfile and AgentProfile set for a project."""
+
+    def __init__(self, detector: ProfileDetector | None = None) -> None:
+        self.detector = detector or ProfileDetector()
+
+    def resolve(self, project_root: Path) -> tuple[ProjectProfile, tuple[AgentProfile, ...]]:
+        detections = self.detector.detect(project_root)
+        return self.resolve_detections(project_root, detections)
+
+    def resolve_detections(
+        self,
+        project_root: Path,
+        detections: tuple[DetectionResult, ...],
+    ) -> tuple[ProjectProfile, tuple[AgentProfile, ...]]:
+        profile_ids = tuple(result.profile_id for result in detections)
+        contracts = build_agent_catalog(profile_ids)
+        agents = tuple(
+            AgentProfile(
+                id=agent.id,
+                role=agent.role,
+                profile_ids=profile_ids,
+                capabilities=agent.capabilities,
+                tools=agent.tools,
+                permissions=agent.permissions,
+                model_ids=agent.model_ids,
+                metadata=dict(agent.metadata),
+            )
+            for agent in contracts
+        )
+        project = ProjectProfile(
+            id=self._project_id(project_root),
+            root=str(project_root),
+            technology_profile_ids=profile_ids,
+            agent_profile_ids=tuple(agent.id for agent in agents),
+            metadata={
+                "detection": [
+                    {
+                        "profile": result.profile_id,
+                        "confidence": result.confidence,
+                        "evidence": list(result.evidence),
+                    }
+                    for result in detections
+                ]
+            },
+        )
+        return project, agents
+
+    @staticmethod
+    def _project_id(project_root: Path) -> str:
+        name = project_root.name.strip()
+        return name or "project"

runtime/__init__.py

@@ -0,0 +1,5 @@
+"""VYRELON runtime facade exports."""
+
+from runtime.vyrelon import VYRELONRuntime
+
+__all__ = ["VYRELONRuntime"]

runtime/agent/__init__.py

@@ -0,0 +1 @@
+"""Agent runtime adapters."""

runtime/agent/ide.py

@@ -0,0 +1,74 @@
+"""Agent execution helpers for IDE-originated coding work."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from core.contracts.agent import AgentContract
+from core.contracts.execution import AgentExecutor
+from core.contracts.work_unit import WorkUnit
+from core.contracts.model_runtime import ModelResponse
+from runtime.tool_calling import ToolRuntime
+from runtime.policy import ExecutionPolicy
+from runtime.validation import ValidationReport, ValidationRuntime, ValidationStep
+
+
+@dataclass
+class IDECodingExecutor:
+    """Execute a model request and optionally materialize its patch into the project."""
+
+    delegate: AgentExecutor
+    project_root: Path
+    apply_changes: bool = False
+    policy: ExecutionPolicy | None = None
+    tool_runtime: ToolRuntime | None = None
+
+    def execute(self, *, agent: AgentContract, model_id: str, work_unit: WorkUnit) -> object:
+        execute_with_tools = getattr(self.delegate, "execute_with_tools", None)
+        if self.tool_runtime is not None and callable(execute_with_tools):
+            execution = execute_with_tools(
+                agent=agent,
+                model_id=model_id,
+                work_unit=work_unit,
+                tool_runtime=self.tool_runtime,
+                approved=self.apply_changes,
+            )
+            output = execution.response
+            changed = any(
+                result.tool_id == "patch.apply" and result.ok
+                for result in execution.tool_results
+            )
+            work_unit.metadata["code_change"] = changed
+            work_unit.metadata["patch_applied"] = changed
+            return output
+
+        output = self.delegate.execute(agent=agent, model_id=model_id, work_unit=work_unit)
+        if not isinstance(output, ModelResponse):
+            return output
+        work_unit.metadata["code_change"] = False
+        return output
+
+
+@dataclass
+class IDEValidationVerifier:
+    """Validate an IDE-originated code change using VYRELON's local validation boundary."""
+
+    project_root: Path
+    commands: tuple[str, ...]
+    policy: ExecutionPolicy | None = None
+
+    def verify(self, *, work_unit: WorkUnit, output: object) -> bool:
+        if not self.commands:
+            work_unit.metadata["validation_skipped"] = True
+            return True
+        report: ValidationReport = ValidationRuntime(self.policy).run(
+            self.project_root,
+            (
+                ValidationStep(id=f"ide-validation-{index}", command=command)
+                for index, command in enumerate(self.commands, start=1)
+            ),
+        )
+        work_unit.metadata["validation_passed"] = report.passed
+        work_unit.metadata["validation_evidence"] = report.evidence
+        return report.passed

runtime/agent/model.py

@@ -0,0 +1,197 @@
+"""Model-backed AgentExecutor for provider-neutral VYRELON agents."""
+
+from __future__ import annotations
+
+from core.contracts.agent import AgentContract
+from core.contracts.ai import ModelSpec
+from core.contracts.execution import AgentExecutor
+from core.contracts.model_runtime import ModelAdapter, ModelRequest, ModelResponse
+from runtime.quota import QuotaIntelligence
+from runtime.capability import CapabilityRegistry
+from runtime.health import ModelHealthRegistry
+from runtime.model_control import ModelControlPlane
+from runtime.tool_calling import ToolCallingExecution, ToolCallingRuntime, ToolRuntime
+from core.contracts.work_unit import WorkUnit
+
+
+class ModelAgentExecutor(AgentExecutor):
+    """Turn a WorkUnit into a model request and return the model response."""
+
+    def __init__(
+        self,
+        adapters: dict[str, ModelAdapter],
+        models: list[ModelSpec],
+        system_prompt: str | None = None,
+        fallback_model_ids: tuple[str, ...] = (),
+        quota_intelligence: QuotaIntelligence | None = None,
+        health_registry: ModelHealthRegistry | None = None,
+        model_control: ModelControlPlane | None = None,
+        capability_registry: CapabilityRegistry | None = None,
+    ):
+        self.adapters = dict(adapters)
+        self.models = {model.id: model for model in models}
+        self.system_prompt = system_prompt
+        self.fallback_model_ids = tuple(fallback_model_ids)
+        self.quota_intelligence = quota_intelligence
+        self.health_registry = health_registry
+        self.model_control = model_control
+        self.capability_registry = capability_registry
+
+    def _candidate_model_ids(self, model_id: str) -> tuple[str, ...]:
+        return tuple(dict.fromkeys((model_id, *self.fallback_model_ids)))
+
+    @staticmethod
+    def _is_failover_error(exc: Exception) -> bool:
+        """Return True for errors where another model/provider may succeed."""
+        status = getattr(exc, "status_code", getattr(exc, "status", None))
+        code = str(getattr(exc, "code", "")).lower()
+        message = str(exc).lower()
+        if status in {408, 429, 500, 502, 503, 504}:
+            return True
+        transient_codes = (
+            "rate_limit", "rate-limit", "quota", "resource_exhausted",
+            "too_many_requests", "temporarily_unavailable",
+            "service_unavailable", "unavailable", "overloaded", "timeout",
+        )
+        return any(token in code or token in message for token in transient_codes)
+
+    def execute(
+        self, *, agent: AgentContract, model_id: str, work_unit: WorkUnit
+    ) -> ModelResponse:
+        attempts: list[str] = []
+        last_error: Exception | None = None
+        for candidate_id in self._candidate_model_ids(model_id):
+            if agent.model_ids and candidate_id not in agent.model_ids:
+                continue
+            try:
+                model = self.models[candidate_id]
+                adapter_id = str(model.metadata.get("adapter_id", model.provider_id))
+                adapter = self.adapters[adapter_id]
+                system = self.system_prompt or str(agent.metadata.get("system_prompt", "")) or None
+                request = ModelRequest(
+                    prompt=work_unit.objective,
+                    system=system,
+                    metadata={"agent_id": agent.id, "work_unit_id": work_unit.id, "attempts": tuple(attempts)},
+                )
+                response = adapter.generate(model, request)
+                attempts.append(candidate_id)
+                metadata = dict(response.metadata)
+                metadata["attempts"] = tuple(attempts)
+                response = ModelResponse(
+                    text=response.text,
+                    model_id=response.model_id or candidate_id,
+                    metadata=metadata,
+                )
+                work_unit.metadata["model_response"] = response.text
+                work_unit.metadata["model_id"] = response.model_id
+                work_unit.metadata["model_adapter"] = adapter_id
+                work_unit.metadata["model_attempts"] = tuple(attempts)
+                if self.capability_registry is not None:
+                    self.capability_registry.observe_response(model, metadata)
+                if self.quota_intelligence is not None:
+                    snapshot = self.quota_intelligence.observe_response(model, metadata)
+                    work_unit.metadata["quota_snapshot"] = {
+                        "confidence": snapshot.confidence.value,
+                        "dimensions": {
+                            item.name: {"remaining": item.remaining, "limit": item.limit}
+                            for item in snapshot.dimensions
+                        },
+                    }
+                if self.model_control is not None:
+                    self.model_control.record_success(model, metadata)
+                elif self.health_registry is not None:
+                    self.health_registry.record_success(candidate_id, model.provider_id)
+                return response
+            except Exception as exc:
+                attempts.append(candidate_id)
+                last_error = exc
+                if self.model_control is not None and candidate_id in self.models:
+                    self.model_control.record_failure(self.models[candidate_id], exc)
+                elif self.health_registry is not None and candidate_id in self.models:
+                    self.health_registry.record_failure(candidate_id, self.models[candidate_id].provider_id, exc)
+                if not self._is_failover_error(exc):
+                    raise
+        if last_error is not None:
+            raise last_error
+        raise LookupError(f"No executable model available for agent {agent.id}")
+
+    def execute_with_tools(
+        self,
+        *,
+        agent: AgentContract,
+        model_id: str,
+        work_unit: WorkUnit,
+        tool_runtime: ToolRuntime,
+        approved: bool = False,
+    ) -> ToolCallingExecution:
+        """Execute the selected model through Tool Calling with ordered fallback."""
+        attempts: list[str] = []
+        last_error: Exception | None = None
+        for candidate_id in self._candidate_model_ids(model_id):
+            if agent.model_ids and candidate_id not in agent.model_ids:
+                continue
+            try:
+                model = self.models.get(candidate_id)
+                if model is None:
+                    raise LookupError(f"Model not registered: {candidate_id}")
+                adapter_id = str(model.metadata.get("adapter_id", model.provider_id))
+                adapter = self.adapters.get(adapter_id)
+                if adapter is None:
+                    raise LookupError(f"Model adapter not registered: {adapter_id}")
+                request = ModelRequest(
+                    prompt=work_unit.objective,
+                    system=self.system_prompt or str(agent.metadata.get("system_prompt", "")) or None,
+                    metadata={
+                        "agent_id": agent.id,
+                        "work_unit_id": work_unit.id,
+                        "attempts": tuple(attempts),
+                    },
+                )
+                runtime = ToolCallingRuntime(
+                    models={candidate_id: model},
+                    adapters={candidate_id: adapter},
+                    tools=tool_runtime,
+                )
+                result = runtime.execute(
+                    request,
+                    model_id=candidate_id,
+                    work_unit_id=work_unit.id,
+                    granted_permissions=agent.permissions,
+                    approved=approved,
+                )
+                attempts.append(candidate_id)
+                work_unit.metadata["model_response"] = result.response.text
+                work_unit.metadata["model_id"] = result.model_id
+                work_unit.metadata["model_adapter"] = adapter_id
+                work_unit.metadata["tool_rounds"] = result.rounds
+                work_unit.metadata["tool_results"] = tuple(result.tool_results)
+                work_unit.metadata["model_attempts"] = tuple(attempts)
+                if self.capability_registry is not None:
+                    self.capability_registry.observe_response(model, dict(result.response.metadata))
+                if self.quota_intelligence is not None:
+                    snapshot = self.quota_intelligence.observe_response(model, dict(result.response.metadata))
+                    work_unit.metadata["quota_snapshot"] = {
+                        "confidence": snapshot.confidence.value,
+                        "dimensions": {
+                            item.name: {"remaining": item.remaining, "limit": item.limit}
+                            for item in snapshot.dimensions
+                        },
+                    }
+                if self.model_control is not None:
+                    self.model_control.record_success(model, dict(result.response.metadata))
+                elif self.health_registry is not None:
+                    self.health_registry.record_success(candidate_id, model.provider_id)
+                return result
+            except Exception as exc:
+                attempts.append(candidate_id)
+                last_error = exc
+                if self.model_control is not None and candidate_id in self.models:
+                    self.model_control.record_failure(self.models[candidate_id], exc)
+                elif self.health_registry is not None and candidate_id in self.models:
+                    self.health_registry.record_failure(candidate_id, self.models[candidate_id].provider_id, exc)
+                if not self._is_failover_error(exc):
+                    raise
+        if last_error is not None:
+            raise last_error
+        raise LookupError(f"No executable tool-calling model available for agent {agent.id}")
+