multiagentos 0.4.0__py3-none-any.whl

agents/__init__.py

@@ -0,0 +1 @@
+"""Built-in VYRELON agent catalog."""

agents/catalog.py

@@ -0,0 +1,52 @@
+"""Built-in specialist agent definitions."""
+
+from core.contracts.agent import AgentContract
+
+_COMMON = {
+    "planner": ({"planning"}, {"filesystem.read"}),
+    "researcher": ({"research"}, {"network.read"}),
+    "editor": ({"editing"}, {"filesystem.read", "filesystem.write"}),
+    "executor": ({"execution"}, {"filesystem.read", "filesystem.write", "process"}),
+    "tester": ({"testing"}, {"filesystem.read", "process"}),
+    "debugger": ({"debugging"}, {"filesystem.read", "process"}),
+    "reviewer": ({"review"}, {"filesystem.read"}),
+}
+
+_PROFILE_SPECIALISTS = {
+    "react-native": {
+        "architect": ({"architecture", "react-native"}, {"filesystem.read"}),
+        "developer": ({"code", "react-native"}, {"filesystem.read", "filesystem.write"}),
+        "ui": ({"ui", "react-native"}, {"filesystem.read", "filesystem.write"}),
+        "navigation": ({"navigation", "react-native"}, {"filesystem.read", "filesystem.write"}),
+        "state-management": ({"state-management", "react-native"}, {"filesystem.read", "filesystem.write"}),
+    },
+    "android-native": {
+        "android-architect": ({"architecture", "android"}, {"filesystem.read"}),
+        "kotlin-developer": ({"code", "kotlin"}, {"filesystem.read", "filesystem.write"}),
+        "jetpack-compose": ({"ui", "compose", "kotlin"}, {"filesystem.read", "filesystem.write"}),
+        "gradle": ({"build", "gradle"}, {"filesystem.read", "filesystem.write", "process"}),
+    },
+    "ios-native": {
+        "ios-architect": ({"architecture", "ios"}, {"filesystem.read"}),
+        "swift-developer": ({"code", "swift"}, {"filesystem.read", "filesystem.write"}),
+        "swiftui": ({"ui", "swiftui"}, {"filesystem.read", "filesystem.write"}),
+        "xcode": ({"build", "xcode"}, {"filesystem.read", "filesystem.write", "process"}),
+    },
+}
+
+
+def build_agent_catalog(profile_ids: tuple[str, ...] = ()) -> tuple[AgentContract, ...]:
+    definitions: dict[str, tuple[set[str], set[str]]] = dict(_COMMON)
+    for profile_id in profile_ids:
+        definitions.update(_PROFILE_SPECIALISTS.get(profile_id, {}))
+    return tuple(
+        AgentContract(
+            id=agent_id,
+            role=agent_id,
+            capabilities=frozenset(capabilities),
+            tools=frozenset(tools),
+            metadata={"profiles": list(profile_ids)},
+            kind="specialist",
+        )
+        for agent_id, (capabilities, tools) in sorted(definitions.items())
+    )

agents/registry.py

@@ -0,0 +1,11 @@
+"""Agent catalog registration utilities."""
+
+from core.registry import AgentRegistry
+from agents.catalog import build_agent_catalog
+
+
+def build_registry(profile_ids: tuple[str, ...] = ()) -> AgentRegistry:
+    registry = AgentRegistry()
+    for agent in build_agent_catalog(profile_ids):
+        registry.register(agent)
+    return registry

core/__init__.py

@@ -0,0 +1,38 @@
+"""VYRELON orchestration core."""
+
+from core.chat_agent_bridge import ChatAgentBridge, ChatAgentExecutionResult, ChatAgentRequest, ChatAgentResponse
+from core.chat_agent_registry import ChatAgentRegistry, default_chat_agents
+from core.chat_agent_router import ChatAgentAssignment, ChatAgentRouter, ChatAgentRoutingStrategy
+from core.chat_session import ChatSession, ChatSessionStore
+from core.contracts.chat_agent import ChatAgentContract, ChatAgentProvider
+from core.contracts.checkpoint import WorkflowCheckpoint
+from core.contracts.execution import AgentExecutor, ResultReviewer, ResultVerifier, ReviewDecision
+from core.contracts.human_review import HumanReviewDecision
+from core.contracts.resume import WorkflowResumeContext
+from core.contracts.handoff import ReviewContext
+from core.contracts.model_runtime import ModelAdapter, ModelRequest, ModelResponse
+from core.contracts.profile import DetectionResult, ProfileSpec
+from core.contracts.runtime import ExecutionRequest, RuntimeExecutor
+from core.delegation import Delegation, DelegationEngine
+from core.lifecycle import ExecutionInterrupted, LifecycleCoordinator, LifecycleError
+from core.orchestrator import OrchestrationResult, Orchestrator
+from core.planning import BasicPlanner
+from core.state import WorkStateStore
+from core.registry import AIRegistry, AgentRegistry
+from core.routing import AIRouter, Assignment, RoutingStrategy
+
+__all__ = [
+    "AIRegistry", "AgentRegistry", "ChatAgentAssignment", "ChatAgentBridge", "ChatAgentRouter", "ChatAgentRoutingStrategy", "ChatSession", "ChatSessionStore", "ChatAgentExecutionResult", "ChatAgentRequest", "ChatAgentResponse", "ChatAgentRegistry", "ChatAgentContract", "ChatAgentProvider", "AIRouter", "Assignment", "RoutingStrategy",
+    "AgentExecutor", "ResultVerifier", "ResultReviewer", "ReviewDecision", "HumanReviewDecision", "WorkflowResumeContext", "WorkflowCheckpoint", "ReviewContext",
+    "ModelAdapter", "ModelRequest", "ModelResponse",
+    "ExecutionRequest", "RuntimeExecutor",
+    "DetectionResult", "ProfileSpec",
+    "Delegation", "DelegationEngine",
+    "ExecutionInterrupted", "LifecycleCoordinator", "LifecycleError",
+    "OrchestrationResult", "Orchestrator", "BasicPlanner", "WorkStateStore",
+]
+
+from core.multi_agent_workflow import AgentStageResult, MultiAgentWorkflow, MultiAgentWorkflowResult
+
+from core.artifacts import ArtifactStore
+from core.contracts.handoff import ArtifactContract

core/artifacts.py

@@ -0,0 +1,47 @@
+"""Persistent artifact registry for VYRELON workflows."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core.contracts.handoff import ArtifactContract
+
+
+class ArtifactStore:
+    """Persist artifact metadata separately from transient model output."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def save(self, artifact: ArtifactContract) -> Path:
+        artifact.validate()
+        path = self.root / f"{artifact.id}.json"
+        payload = {
+            "id": artifact.id,
+            "kind": artifact.kind,
+            "producer_agent_id": artifact.producer_agent_id,
+            "content_ref": artifact.content_ref,
+            "summary": artifact.summary,
+            "media_type": artifact.media_type,
+            "metadata": artifact.metadata,
+        }
+        path.write_text(
+            json.dumps(payload, indent=2, ensure_ascii=False, default=str) + "\n",
+            encoding="utf-8",
+        )
+        return path
+
+    def load(self, artifact_id: str) -> ArtifactContract:
+        path = self.root / f"{artifact_id}.json"
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return ArtifactContract(
+            id=data["id"],
+            kind=data["kind"],
+            producer_agent_id=data["producer_agent_id"],
+            content_ref=data["content_ref"],
+            summary=data.get("summary", ""),
+            media_type=data.get("media_type", "text/plain"),
+            metadata=dict(data.get("metadata", {})),
+        )

core/chat_agent_bridge.py

@@ -0,0 +1,280 @@
+"""Provider-neutral bridge between a Chat Agent and the VYRELON runtime."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from uuid import uuid4
+from typing import Protocol
+
+from core.chat_agent_registry import ChatAgentRegistry
+from core.contracts.agent import AgentContract
+from core.contracts.ai import ModelSpec
+from core.contracts.chat_agent import ChatAgentContract
+from core.contracts.execution import AgentExecutor, ResultReviewer, ResultVerifier
+from core.contracts.planning import PlanStep, WorkPlan
+from core.contracts.work_unit import WorkUnit
+from core.orchestrator import OrchestrationResult, Orchestrator
+from core.planning import BasicPlanner
+from core.state import WorkStateStore
+from core.chat_session import ChatSession, ChatSessionStore
+
+
+VYRELON_AGENT_RULES: tuple[str, ...] = (
+    "VYRELON is the execution authority.",
+    "Never report an action as completed without execution evidence.",
+    "Inspect relevant repository and runtime state before changing anything.",
+    "Preserve user intent and do not silently expand scope.",
+    "Respect repository boundaries; borrowed material is adapted into the target repository.",
+    "Keep credentials and secrets outside source code and persistent project state.",
+    "Use least privilege and obey VYRELON execution policy.",
+    "Verify changes with appropriate tests or checks before declaring completion.",
+    "Maintain WorkUnit, plan, artifact, finding, and handoff state.",
+    "Consequential Git and GitHub mutations follow VYRELON approval policy.",
+    "No Chat Agent provider has authority above VYRELON contracts.",
+    "Required independent reviewers must not be bypassed.",
+)
+
+
+def build_agent_instructions(agent: ChatAgentContract) -> str:
+    """Build the common instruction envelope for a connected Chat Agent."""
+    rules = "\n".join(f"{index}. {rule}" for index, rule in enumerate(VYRELON_AGENT_RULES, 1))
+    return (
+        f"You are {agent.name}, a VYRELON Chat Agent.\n"
+        f"Provider: {agent.provider.value}.\n"
+        f"Instruction profile: {agent.instruction_profile}.\n\n"
+        "Follow these mandatory VYRELON Agent Rules:\n"
+        f"{rules}\n\n"
+        "VYRELON is the execution authority. Use the capabilities exposed by VYRELON "
+        "rather than inventing tool execution or bypassing runtime policy."
+    )
+
+
+@dataclass(frozen=True)
+class ChatAgentRequest:
+    """A user task entering VYRELON through a Chat Agent."""
+
+    objective: str
+    inputs: dict[str, object] | None = None
+    work_unit_id: str | None = None
+
+
+@dataclass(frozen=True)
+class ChatAgentResponse:
+    """Structured response returned by a Chat Agent adapter."""
+
+    summary: str
+    steps: tuple[PlanStep, ...] = ()
+    findings: tuple[str, ...] = ()
+    artifacts: tuple[str, ...] = ()
+    evidence: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class ChatAgentExecutionResult:
+    """The complete result of turning a Chat Agent turn into VYRELON execution."""
+
+    work_unit: WorkUnit
+    plan: WorkPlan
+    chat_response: ChatAgentResponse
+    orchestration: OrchestrationResult
+
+
+class ChatAgentAdapter(Protocol):
+    """Provider adapter implemented by a connected Chat Agent."""
+
+    def respond(
+        self,
+        *,
+        agent: ChatAgentContract,
+        instructions: str,
+        request: ChatAgentRequest,
+    ) -> ChatAgentResponse:
+        """Return a structured response without directly owning VYRELON execution."""
+
+
+class ChatAgentBridge:
+    """Translate Chat Agent turns into VYRELON WorkUnits, Plans, and execution."""
+
+    def __init__(
+        self,
+        registry: ChatAgentRegistry,
+        planner: BasicPlanner | None = None,
+        orchestrator: Orchestrator | None = None,
+    ) -> None:
+        self.registry = registry
+        self.planner = planner or BasicPlanner()
+        self.orchestrator = orchestrator or Orchestrator()
+
+    def instructions(self, agent_id: str | None = None) -> str:
+        agent = self.registry.get(agent_id) if agent_id else self.registry.primary()
+        return build_agent_instructions(agent)
+
+    def request(
+        self,
+        request: ChatAgentRequest,
+        adapter: ChatAgentAdapter,
+        agent_id: str | None = None,
+    ) -> tuple[WorkUnit, WorkPlan, ChatAgentResponse]:
+        agent = self.registry.get(agent_id) if agent_id else self.registry.primary()
+        if not request.objective.strip():
+            raise ValueError("chat agent objective must not be empty")
+
+        work_unit = WorkUnit(
+            id=request.work_unit_id or f"chat-{agent.id}-{uuid4().hex}",
+            objective=request.objective,
+            inputs=dict(request.inputs or {}),
+        )
+        response = adapter.respond(
+            agent=agent,
+            instructions=build_agent_instructions(agent),
+            request=request,
+        )
+        plan = self.planner.plan(work_unit, list(response.steps))
+        work_unit.metadata["chat_agent_id"] = agent.id
+        work_unit.metadata["chat_agent_summary"] = response.summary
+        work_unit.metadata["chat_agent_findings"] = list(response.findings)
+        work_unit.metadata["chat_agent_evidence"] = list(response.evidence)
+        work_unit.artifacts.extend(response.artifacts)
+        return work_unit, plan, response
+
+    def execute(
+        self,
+        request: ChatAgentRequest,
+        adapter: ChatAgentAdapter,
+        agent: AgentContract,
+        models: list[ModelSpec],
+        executor: AgentExecutor,
+        *,
+        chat_agent_id: str | None = None,
+        preferred_model_ids: list[str] | None = None,
+        verifier: ResultVerifier | None = None,
+        reviewer: ResultReviewer | None = None,
+        routing_strategy="pool",
+        state_store: WorkStateStore | None = None,
+        session_store: ChatSessionStore | None = None,
+        session: ChatSession | None = None,
+    ) -> ChatAgentExecutionResult:
+        """Run a Chat Agent request through the VYRELON execution lifecycle.
+
+        The Chat Agent supplies intent and planning. The supplied AgentContract,
+        model pool, executor, verifier, and reviewer determine actual execution.
+        """
+        work_unit, plan, response = self.request(
+            request, adapter, agent_id=chat_agent_id
+        )
+        work_unit.metadata["execution_authority"] = "vyrelon"
+        work_unit.metadata["execution_agent_id"] = agent.id
+        if session is not None:
+            session.work_unit_id = work_unit.id
+            session.metadata["execution_agent_id"] = agent.id
+        checkpoint_sequence = 0
+
+        def checkpoint(unit: WorkUnit) -> None:
+            nonlocal checkpoint_sequence
+            checkpoint_sequence += 1
+            unit.metadata["checkpoint"] = {
+                "status": unit.status.value,
+                "sequence": checkpoint_sequence,
+            }
+            if state_store is not None:
+                state_store.checkpoint(
+                    unit,
+                    workflow="chat_execution",
+                    stage=unit.status.value,
+                    sequence=checkpoint_sequence,
+                    next_action=(
+                        "resume_execution"
+                        if unit.status.value not in {"completed", "failed"}
+                        else None
+                    ),
+                    agent_ids=(agent.id,),
+                    model_ids=tuple(model.id for model in models),
+                    resumable=unit.status.value not in {"completed", "failed"},
+                )
+            if session is not None:
+                session.metadata["lifecycle_status"] = unit.status.value
+                if session_store is not None:
+                    session_store.save(session)
+        checkpoint(work_unit)
+        orchestration = self.orchestrator.run(
+            work_unit=work_unit,
+            agent=agent,
+            models=models,
+            executor=executor,
+            preferred_model_ids=preferred_model_ids,
+            verifier=verifier,
+            reviewer=reviewer,
+            routing_strategy=routing_strategy,
+            checkpoint=checkpoint,
+        )
+        work_unit.metadata["execution_evidence"] = [
+            f"VYRELON execution completed with agent {agent.id}",
+            f"assigned model: {orchestration.delegation.assignment.model_id}",
+        ]
+        if verifier is not None:
+            work_unit.metadata["verification_evidence"] = ["VYRELON verifier accepted output"]
+        if reviewer is not None:
+            work_unit.metadata["review_evidence"] = ["VYRELON reviewer approved output"]
+        return ChatAgentExecutionResult(
+            work_unit=work_unit,
+            plan=plan,
+            chat_response=response,
+            orchestration=orchestration,
+        )
+
+    
+    def resume(
+        self,
+        work_unit_id: str,
+        *,
+        state_store: WorkStateStore,
+        agent: AgentContract,
+        models: list[ModelSpec],
+        executor: AgentExecutor,
+        verifier: ResultVerifier | None = None,
+        reviewer: ResultReviewer | None = None,
+        preferred_model_ids: list[str] | None = None,
+        routing_strategy="pool",
+    ) -> OrchestrationResult:
+        """Resume a persisted WorkUnit after interruption."""
+        work_unit = state_store.load(work_unit_id)
+        if work_unit.status.value == "completed":
+            raise ValueError(f"work unit is already completed: {work_unit_id}")
+        if work_unit.status.value == "failed":
+            raise ValueError(f"failed work unit requires explicit retry policy: {work_unit_id}")
+
+        checkpoint_sequence = 0
+
+        def checkpoint(unit: WorkUnit) -> None:
+            nonlocal checkpoint_sequence
+            checkpoint_sequence += 1
+            unit.metadata["checkpoint"] = {
+                "status": unit.status.value,
+                "sequence": checkpoint_sequence,
+            }
+            state_store.checkpoint(
+                unit,
+                workflow="chat_execution",
+                stage=unit.status.value,
+                sequence=checkpoint_sequence,
+                next_action=(
+                    "resume_execution"
+                    if unit.status.value not in {"completed", "failed"}
+                    else None
+                ),
+                agent_ids=(agent.id,),
+                model_ids=tuple(model.id for model in models),
+                resumable=unit.status.value not in {"completed", "failed"},
+            )
+
+        return self.orchestrator.run(
+            work_unit=work_unit,
+            agent=agent,
+            models=models,
+            executor=executor,
+            preferred_model_ids=preferred_model_ids,
+            verifier=verifier,
+            reviewer=reviewer,
+            routing_strategy=routing_strategy,
+            checkpoint=checkpoint,
+        )

core/chat_agent_registry.py

@@ -0,0 +1,61 @@
+"""Registry for chat-facing AI agents."""
+
+from __future__ import annotations
+
+from core.contracts.chat_agent import ChatAgentContract, ChatAgentProvider
+
+
+class ChatAgentRegistry:
+    def __init__(self) -> None:
+        self._agents: dict[str, ChatAgentContract] = {}
+
+    def register(self, agent: ChatAgentContract) -> None:
+        agent.validate()
+        if agent.id in self._agents:
+            raise ValueError(f"chat agent already registered: {agent.id}")
+        self._agents[agent.id] = agent
+
+    def get(self, agent_id: str) -> ChatAgentContract:
+        return self._agents[agent_id]
+
+    def primary(self) -> ChatAgentContract:
+        for agent in self._agents.values():
+            if agent.primary:
+                return agent
+        raise LookupError("no primary chat agent registered")
+
+    def list(self) -> tuple[ChatAgentContract, ...]:
+        return tuple(sorted(self._agents.values(), key=lambda agent: agent.id))
+
+
+def default_chat_agents() -> ChatAgentRegistry:
+    registry = ChatAgentRegistry()
+    registry.register(
+        ChatAgentContract(
+            id="chatgpt",
+            provider=ChatAgentProvider.CHATGPT,
+            name="ChatGPT Agent",
+            capabilities=frozenset({"conversation", "planning", "orchestration"}),
+            instruction_profile="vyrelon",
+            primary=True,
+        )
+    )
+    registry.register(
+        ChatAgentContract(
+            id="gemini",
+            provider=ChatAgentProvider.GEMINI,
+            name="Gemini Agent",
+            capabilities=frozenset({"conversation", "planning"}),
+            instruction_profile="vyrelon",
+        )
+    )
+    registry.register(
+        ChatAgentContract(
+            id="claude",
+            provider=ChatAgentProvider.CLAUDE,
+            name="Claude Agent",
+            capabilities=frozenset({"conversation", "planning"}),
+            instruction_profile="vyrelon",
+        )
+    )
+    return registry

core/chat_agent_router.py

@@ -0,0 +1,85 @@
+"""Routing policy for provider-neutral Chat Agents."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from core.chat_agent_registry import ChatAgentRegistry
+from core.contracts.chat_agent import ChatAgentContract
+
+
+class ChatAgentRoutingStrategy(str, Enum):
+    EXPLICIT = "explicit"
+    FALLBACK = "fallback"
+    AUTO = "auto"
+
+
+@dataclass(frozen=True)
+class ChatAgentAssignment:
+    agent: ChatAgentContract
+    strategy: ChatAgentRoutingStrategy
+    candidates: tuple[str, ...]
+
+
+class ChatAgentRouter:
+    """Select a Chat Agent without giving any provider execution authority."""
+
+    def __init__(self, registry: ChatAgentRegistry) -> None:
+        self.registry = registry
+
+    def route(
+        self,
+        *,
+        preferred_agent_id: str | None = None,
+        fallback_agent_ids: tuple[str, ...] = (),
+        required_capabilities: frozenset[str] = frozenset(),
+        strategy: ChatAgentRoutingStrategy | str = ChatAgentRoutingStrategy.AUTO,
+    ) -> ChatAgentAssignment:
+        strategy = ChatAgentRoutingStrategy(strategy)
+        candidates: list[ChatAgentContract] = []
+
+        if preferred_agent_id is not None:
+            candidates.append(self.registry.get(preferred_agent_id))
+
+        for agent_id in fallback_agent_ids:
+            agent = self.registry.get(agent_id)
+            if agent.id not in {item.id for item in candidates}:
+                candidates.append(agent)
+
+        if strategy is ChatAgentRoutingStrategy.AUTO and not candidates:
+            candidates.extend(self.registry.list())
+
+        if strategy is ChatAgentRoutingStrategy.EXPLICIT:
+            if preferred_agent_id is None:
+                raise ValueError("explicit chat-agent routing requires preferred_agent_id")
+            candidates = [self.registry.get(preferred_agent_id)]
+
+        if strategy is ChatAgentRoutingStrategy.FALLBACK and not candidates:
+            raise ValueError("fallback chat-agent routing requires candidates")
+
+        compatible = [
+            agent for agent in candidates
+            if required_capabilities.issubset(agent.capabilities)
+        ]
+        if not compatible:
+            raise LookupError(
+                "no chat agent satisfies required capabilities: "
+                + ", ".join(sorted(required_capabilities))
+            )
+
+        # AUTO prefers the registered primary ChatGPT agent when it is compatible.
+        if strategy is ChatAgentRoutingStrategy.AUTO:
+            primary = self.registry.primary()
+            if primary in compatible:
+                selected = primary
+            else:
+                selected = compatible[0]
+        else:
+            selected = compatible[0]
+
+        return ChatAgentAssignment(
+            agent=selected,
+            strategy=strategy,
+            candidates=tuple(agent.id for agent in compatible),
+        )

core/chat_session.py

@@ -0,0 +1,62 @@
+"""Persistent conversational session state for VYRELON Chat Agents."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import json
+from datetime import datetime, timezone
+
+
+@dataclass
+class ChatSession:
+    id: str
+    chat_agent_id: str
+    work_unit_id: str | None = None
+    turns: list[dict[str, object]] = field(default_factory=list)
+    metadata: dict[str, object] = field(default_factory=dict)
+    updated_at: str = ""
+
+    def add_turn(self, role: str, content: str, **metadata: object) -> None:
+        self.turns.append(
+            {"role": role, "content": content, "metadata": metadata}
+        )
+        self.updated_at = datetime.now(timezone.utc).isoformat()
+
+
+class ChatSessionStore:
+    """Store Chat Agent conversation state separately from provider credentials."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def save(self, session: ChatSession) -> Path:
+        if not session.updated_at:
+            session.updated_at = datetime.now(timezone.utc).isoformat()
+        path = self.root / f"{session.id}.json"
+        payload = {
+            "id": session.id,
+            "chat_agent_id": session.chat_agent_id,
+            "work_unit_id": session.work_unit_id,
+            "turns": session.turns,
+            "metadata": session.metadata,
+            "updated_at": session.updated_at,
+        }
+        path.write_text(
+            json.dumps(payload, indent=2, ensure_ascii=False, default=str) + "\n",
+            encoding="utf-8",
+        )
+        return path
+
+    def load(self, session_id: str) -> ChatSession:
+        path = self.root / f"{session_id}.json"
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return ChatSession(
+            id=data["id"],
+            chat_agent_id=data["chat_agent_id"],
+            work_unit_id=data.get("work_unit_id"),
+            turns=list(data.get("turns", [])),
+            metadata=dict(data.get("metadata", {})),
+            updated_at=data.get("updated_at", ""),
+        )

core/contracts/__init__.py

@@ -0,0 +1,22 @@
+"""VYRELON core contracts."""
+
+from core.contracts.chat_agent import ChatAgentContract, ChatAgentProvider
+from core.contracts.agent import AgentContract
+from core.contracts.ai import AIProvider, ModelSpec
+from core.contracts.execution import AgentExecutor, ResultReviewer, ResultVerifier, ReviewDecision
+from core.contracts.mcp import MCPServerSpec, MCPSession, MCPTool, MCPToolCall, MCPToolResult
+from core.contracts.model_runtime import ModelAdapter, ModelRequest, ModelResponse
+from core.contracts.health import HealthStatus, ModelHealth
+from core.contracts.runtime import ExecutionRequest, RuntimeExecutor
+from core.contracts.work_unit import WorkStatus, WorkUnit
+from core.contracts.profile import DetectionResult, ProfileSpec
+from core.contracts.planning import PlanStep, WorkPlan
+
+__all__ = [
+    "AgentContract", "ChatAgentContract", "ChatAgentProvider", "AIProvider", "ModelSpec",
+    "AgentExecutor", "ResultVerifier", "ResultReviewer", "ReviewDecision",
+    "MCPServerSpec", "MCPSession", "MCPTool", "MCPToolCall", "MCPToolResult",
+    "ModelAdapter", "ModelRequest", "ModelResponse", "HealthStatus", "ModelHealth",
+    "ExecutionRequest", "RuntimeExecutor", "DetectionResult", "ProfileSpec",
+    "PlanStep", "WorkPlan", "WorkStatus", "WorkUnit",
+]