coreason-manifest 0.6.0__tar.gz → 0.7.0__tar.gz

{coreason_manifest-0.6.0 → coreason_manifest-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreason_manifest
-Version: 0.6.0
+Version: 0.7.0
 Summary: This package is the definitive source of truth. If it isn't in the manifest, it doesn't exist. If it violates the manifest, it doesn't run.
 License: # The Prosperity Public License 3.0.0
          
@@ -67,16 +67,10 @@ Requires-Python: >=3.12
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
-Requires-Dist: aiofiles (>=23.2.1,<24.0.0)
-Requires-Dist: anyio (>=4.12.1,<5.0.0)
 Requires-Dist: coreason-identity (>=0.4.1,<0.5.0)
-Requires-Dist: fastapi (>=0.128.0,<0.129.0)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: jsonschema (>=4.26.0,<5.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: pydantic (>=2.12.5,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
-Requires-Dist: uvicorn (>=0.40.0,<0.41.0)
 Project-URL: Documentation, https://github.com/CoReason-AI/coreason_manifest
 Project-URL: Homepage, https://github.com/CoReason-AI/coreason_manifest
 Project-URL: Repository, https://github.com/CoReason-AI/coreason_manifest

{coreason_manifest-0.6.0 → coreason_manifest-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "coreason_manifest"
-version = "0.6.0"
+version = "0.7.0"
 description = "This package is the definitive source of truth. If it isn't in the manifest, it doesn't exist. If it violates the manifest, it doesn't run."
 authors = ["Gowtham A Rao <gowtham.rao@coreason.ai>"]
 license = "Prosperity-3.0"
@@ -11,14 +11,8 @@ packages = [{include = "coreason_manifest", from = "src"}]
 python = ">=3.12, <3.15"
 loguru = "^0.7.2"
 pydantic = "^2.12.5"
-jsonschema = "^4.26.0"
 pyyaml = "^6.0.3"
-anyio = "^4.12.1"
 coreason-identity = "^0.4.1"
-httpx = "^0.28.1"
-aiofiles = "^23.2.1"
-fastapi = "^0.128.0"
-uvicorn = "^0.40.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^9.0.2"
@@ -29,8 +23,8 @@ mkdocs = "^1.6.1"
 mkdocs-material = "^9.7.1"
 pydantic = "^2.12.5"
 mypy = "^1.19.1"
-types-aiofiles = "^23.2.0"
 pytest-asyncio = "^1.3.0"
+types-pyyaml = "^6.0.12.20250915"
 
 [build-system]
 requires = ["poetry-core"]
@@ -38,7 +32,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "coreason_manifest"
-version = "0.6.0"
+version = "0.7.0"
 description = "This package is the definitive source of truth. If it isn't in the manifest, it doesn't exist. If it violates the manifest, it doesn't run."
 readme = "README.md"
 requires-python = ">=3.12"

coreason_manifest-0.7.0/src/coreason_manifest/__init__.py

@@ -0,0 +1,17 @@
+from .definitions.agent import AgentDefinition
+from .definitions.audit import AuditLog
+from .definitions.simulation import SimulationScenario, SimulationTrace, SimulationTurn
+from .definitions.topology import Edge, Node, Topology
+from .recipes import RecipeManifest
+
+__all__ = [
+    "AgentDefinition",
+    "Topology",
+    "Node",
+    "Edge",
+    "SimulationScenario",
+    "SimulationTrace",
+    "SimulationTurn",
+    "AuditLog",
+    "RecipeManifest",
+]

coreason_manifest-0.7.0/src/coreason_manifest/definitions/audit.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class AuditLog(BaseModel):
+    """Audit log entry."""
+
+    pass

coreason_manifest-0.7.0/src/coreason_manifest/definitions/simulation.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+
+
+class SimulationScenario(BaseModel):
+    """Definition of a simulation scenario."""
+
+    pass
+
+
+class SimulationTrace(BaseModel):
+    """Trace of a simulation execution."""
+
+    pass
+
+
+class SimulationTurn(BaseModel):
+    """A single turn in a simulation."""
+
+    pass

coreason_manifest-0.6.0/src/coreason_manifest/recipes.py → coreason_manifest-0.7.0/src/coreason_manifest/definitions/topology.py

@@ -8,12 +8,10 @@
 #
 # Source Code: https://github.com/CoReason-AI/coreason_maco
 
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
+from typing import Annotated, List, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from .models import VersionStr
-
 
 class CouncilConfig(BaseModel):
     """Configuration for 'Architectural Triangulation'.
@@ -139,23 +137,4 @@ class GraphTopology(BaseModel):
     edges: List[Edge] = Field(..., description="List of edges connecting the nodes.")
 
 
-class RecipeManifest(BaseModel):
-    """The executable specification for the MACO engine.
-
-    Attributes:
-        id: Unique identifier for the recipe.
-        version: Version of the recipe.
-        name: Human-readable name of the recipe.
-        description: Detailed description of the recipe.
-        inputs: Schema defining global variables this recipe accepts.
-        graph: The topology definition of the workflow.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-    id: str = Field(..., description="Unique identifier for the recipe.")
-    version: VersionStr = Field(..., description="Version of the recipe.")
-    name: str = Field(..., description="Human-readable name of the recipe.")
-    description: Optional[str] = Field(None, description="Detailed description of the recipe.")
-    inputs: Dict[str, Any] = Field(..., description="Schema defining global variables this recipe accepts.")
-    graph: GraphTopology = Field(..., description="The topology definition of the workflow.")
+Topology = GraphTopology

coreason_manifest-0.7.0/src/coreason_manifest/recipes.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2025 CoReason, Inc.
+#
+# This software is proprietary and dual-licensed.
+# Licensed under the Prosperity Public License 3.0 (the "License").
+# A copy of the license is available at https://prosperitylicense.com/versions/3.0.0
+# For details, see the LICENSE file.
+# Commercial use beyond a 30-day trial requires a separate license.
+#
+# Source Code: https://github.com/CoReason-AI/coreason_maco
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .definitions.agent import VersionStr
+from .definitions.topology import GraphTopology
+
+
+class RecipeManifest(BaseModel):
+    """The executable specification for the MACO engine.
+
+    Attributes:
+        id: Unique identifier for the recipe.
+        version: Version of the recipe.
+        name: Human-readable name of the recipe.
+        description: Detailed description of the recipe.
+        inputs: Schema defining global variables this recipe accepts.
+        graph: The topology definition of the workflow.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: str = Field(..., description="Unique identifier for the recipe.")
+    version: VersionStr = Field(..., description="Version of the recipe.")
+    name: str = Field(..., description="Human-readable name of the recipe.")
+    description: Optional[str] = Field(None, description="Detailed description of the recipe.")
+    inputs: Dict[str, Any] = Field(..., description="Schema defining global variables this recipe accepts.")
+    graph: GraphTopology = Field(..., description="The topology definition of the workflow.")

coreason_manifest-0.6.0/src/coreason_manifest/__init__.py

@@ -1,79 +0,0 @@
-# Prosperity-3.0
-"""Coreason Manifest Package.
-
-This package provides the core functionality for the Coreason Manifest system,
-including loading, validation, policy enforcement, and integrity checking of
-agent definitions.
-
-The `coreason-manifest` package serves as the definitive source of truth for
-Asset definitions in the CoReason-AI ecosystem.
-
-Usage:
-    from coreason_manifest import ManifestEngine, ManifestConfig
-
-    config = ManifestConfig(policy_path="./policies/gx_compliant.rego")
-    engine = ManifestEngine(config)
-    agent_def = engine.load_and_validate("agent.yaml", "./src")
-"""
-
-from .engine import ManifestConfig, ManifestEngine, ManifestEngineAsync
-from .errors import (
-    IntegrityCompromisedError,
-    ManifestError,
-    ManifestSyntaxError,
-    PolicyViolationError,
-)
-from .integrity import IntegrityChecker
-from .loader import ManifestLoader
-from .models import (
-    AgentDefinition,
-    AgentDependencies,
-    AgentInterface,
-    AgentMetadata,
-    AgentTopology,
-    ModelConfig,
-    Step,
-)
-from .policy import PolicyEnforcer
-from .recipes import (
-    AgentNode,
-    CouncilConfig,
-    Edge,
-    GraphTopology,
-    HumanNode,
-    LogicNode,
-    Node,
-    RecipeManifest,
-    VisualMetadata,
-)
-from .validator import SchemaValidator
-
-__all__ = [
-    "AgentDefinition",
-    "AgentDependencies",
-    "AgentInterface",
-    "AgentMetadata",
-    "AgentNode",
-    "AgentTopology",
-    "CouncilConfig",
-    "Edge",
-    "GraphTopology",
-    "HumanNode",
-    "IntegrityChecker",
-    "IntegrityCompromisedError",
-    "LogicNode",
-    "ManifestConfig",
-    "ManifestEngine",
-    "ManifestEngineAsync",
-    "ManifestError",
-    "ManifestLoader",
-    "ManifestSyntaxError",
-    "ModelConfig",
-    "Node",
-    "PolicyEnforcer",
-    "PolicyViolationError",
-    "RecipeManifest",
-    "SchemaValidator",
-    "Step",
-    "VisualMetadata",
-]

coreason_manifest-0.6.0/src/coreason_manifest/engine.py

@@ -1,222 +0,0 @@
-# Prosperity-3.0
-"""Engine for the Coreason Manifest system.
-
-This module provides the main entry point for verifying and loading Agent Manifests.
-It coordinates schema validation, policy enforcement, and integrity checking.
-"""
-
-from __future__ import annotations
-
-import time
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, List, Optional, Union, cast
-
-import anyio
-import anyio.to_thread
-
-from coreason_manifest.integrity import IntegrityChecker
-from coreason_manifest.loader import ManifestLoader
-from coreason_manifest.models import AgentDefinition
-from coreason_manifest.policy import PolicyEnforcer
-from coreason_manifest.utils.logger import logger
-from coreason_manifest.validator import SchemaValidator
-
-
-@dataclass
-class ManifestConfig:
-    """Configuration for the ManifestEngine.
-
-    Attributes:
-        policy_path: Path to the Rego policy file.
-        opa_path: Path to the OPA executable. Defaults to "opa".
-        tbom_path: Optional path to the Trusted Bill of Materials.
-        extra_data_paths: Additional data paths to load into OPA.
-    """
-
-    policy_path: Union[str, Path]
-    opa_path: str = "opa"
-    tbom_path: Optional[Union[str, Path]] = None
-    extra_data_paths: List[Union[str, Path]] = field(default_factory=list)
-
-
-class ManifestEngineAsync:
-    """The async core for verifying and loading Agent Manifests.
-
-    This class coordinates the validation process, including:
-    1.  Loading raw YAML.
-    2.  Validating against JSON Schema.
-    3.  Converting to AgentDefinition Pydantic model (Normalization).
-    4.  Enforcing Policy (Rego).
-    5.  Verifying Integrity (Hash check).
-    """
-
-    def __init__(self, config: ManifestConfig) -> None:
-        """Initialize the ManifestEngineAsync.
-
-        Args:
-            config: Configuration including policy path and OPA path.
-        """
-        self.config = config
-        self.schema_validator = SchemaValidator()
-
-        # Collect data paths
-        data_paths = list(config.extra_data_paths)
-        if config.tbom_path:
-            data_paths.append(config.tbom_path)
-
-        self.policy_enforcer = PolicyEnforcer(
-            policy_path=config.policy_path,
-            opa_path=config.opa_path,
-            data_paths=data_paths,
-        )
-
-    async def __aenter__(self) -> ManifestEngineAsync:
-        """Async context manager entry."""
-        return self
-
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Async context manager exit."""
-        # Clean up resources if necessary.
-        pass
-
-    async def validate_manifest_dict(self, raw_data: dict[str, Any]) -> AgentDefinition:
-        """Validates an Agent Manifest dictionary in memory.
-
-        Performs:
-        1. Normalization (stripping version prefixes)
-        2. Schema Validation
-        3. Model Conversion
-        4. Policy Enforcement
-
-        Does NOT perform Integrity Check (hashing).
-
-        Args:
-            raw_data: The raw dictionary of the manifest.
-
-        Returns:
-            AgentDefinition: The fully validated agent definition.
-
-        Raises:
-            ManifestSyntaxError: If structure or schema is invalid.
-            PolicyViolationError: If business rules are violated.
-        """
-        # 1. Normalization (ensure version string is clean before schema/model validation)
-        # We access the static method on ManifestLoader.
-        ManifestLoader._normalize_data(raw_data)
-
-        # 2. Schema Validation
-        logger.debug("Running Schema Validation...")
-        self.schema_validator.validate(raw_data)
-
-        # 3. Model Conversion (Normalization) (CPU bound)
-        logger.debug("Converting to AgentDefinition...")
-        agent_def = await anyio.to_thread.run_sync(ManifestLoader.load_from_dict, raw_data)
-        logger.info(f"Validating Agent {agent_def.metadata.id} v{agent_def.metadata.version}")
-
-        # 4. Policy Enforcement (Subprocess / Blocking)
-        logger.debug("Enforcing Policies...")
-        # We assume policy is checked against the Normalized data (model dumped back to dict)
-        normalized_data = agent_def.model_dump(mode="json")
-        start_time = time.perf_counter()
-        try:
-            # PolicyEnforcer.evaluate is synchronous and runs subprocess.run, so we wrap it.
-            await anyio.to_thread.run_sync(self.policy_enforcer.evaluate, normalized_data)
-            duration_ms = (time.perf_counter() - start_time) * 1000
-            logger.info(f"Policy Check: Pass - {duration_ms:.2f}ms")
-        except Exception:
-            duration_ms = (time.perf_counter() - start_time) * 1000
-            logger.info(f"Policy Check: Fail - {duration_ms:.2f}ms")
-            raise
-
-        return cast(AgentDefinition, agent_def)
-
-    async def load_and_validate(self, manifest_path: Union[str, Path], source_dir: Union[str, Path]) -> AgentDefinition:
-        """Loads, validates, and verifies an Agent Manifest asynchronously.
-
-        Args:
-            manifest_path: Path to the agent.yaml file.
-            source_dir: Path to the source code directory.
-
-        Returns:
-            AgentDefinition: The fully validated and verified agent definition.
-
-        Raises:
-            ManifestSyntaxError: If structure or schema is invalid.
-            PolicyViolationError: If business rules are violated.
-            IntegrityCompromisedError: If source code hash does not match.
-            FileNotFoundError: If files are missing.
-        """
-        manifest_path = Path(manifest_path)
-        source_dir = Path(source_dir)
-
-        logger.info(f"Validating Agent Manifest: {manifest_path}")
-
-        # 1. Load Raw YAML (I/O)
-        raw_data = await ManifestLoader.load_raw_from_file_async(manifest_path)
-
-        # 2. Validate Manifest Dict (Schema, Model, Policy)
-        agent_def = await self.validate_manifest_dict(raw_data)
-
-        # 5. Integrity Check (Heavy I/O and CPU)
-        logger.debug("Verifying Integrity...")
-        # IntegrityChecker.verify is synchronous and does heavy IO, so we wrap it.
-        await anyio.to_thread.run_sync(IntegrityChecker.verify, agent_def, source_dir, manifest_path)
-
-        logger.info("Agent validation successful.")
-        return agent_def
-
-
-class ManifestEngine:
-    """The Sync Facade for ManifestEngineAsync.
-
-    Allows synchronous usage of the async core via anyio.run.
-    """
-
-    def __init__(self, config: ManifestConfig) -> None:
-        """Initialize the ManifestEngine facade.
-
-        Args:
-            config: Configuration including policy path and OPA path.
-        """
-        self._async = ManifestEngineAsync(config)
-
-    def __getattr__(self, name: str) -> Any:
-        """Delegate attribute access to the async engine instance.
-
-        This ensures backward compatibility for accessing attributes like
-        'config', 'schema_validator', and 'policy_enforcer'.
-        """
-        return getattr(self._async, name)
-
-    def __enter__(self) -> ManifestEngine:
-        """Context manager entry."""
-        anyio.run(self._async.__aenter__)
-        return self
-
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Context manager exit."""
-        anyio.run(self._async.__aexit__, exc_type, exc_val, exc_tb)
-
-    def load_and_validate(self, manifest_path: Union[str, Path], source_dir: Union[str, Path]) -> AgentDefinition:
-        """Loads, validates, and verifies an Agent Manifest synchronously.
-
-        Args:
-            manifest_path: Path to the agent.yaml file.
-            source_dir: Path to the source code directory.
-
-        Returns:
-            AgentDefinition: The fully validated and verified agent definition.
-        """
-        return cast(AgentDefinition, anyio.run(self._async.load_and_validate, manifest_path, source_dir))
-
-    def validate_manifest_dict(self, raw_data: dict[str, Any]) -> AgentDefinition:
-        """Validates an Agent Manifest dictionary synchronously.
-
-        Args:
-            raw_data: The raw dictionary of the manifest.
-
-        Returns:
-            AgentDefinition: The fully validated agent definition.
-        """
-        return cast(AgentDefinition, anyio.run(self._async.validate_manifest_dict, raw_data))

coreason_manifest-0.6.0/src/coreason_manifest/errors.py

@@ -1,53 +0,0 @@
-# Prosperity-3.0
-"""Exceptions for the Coreason Manifest system.
-
-This module defines the hierarchy of exceptions raised by the package.
-"""
-
-from __future__ import annotations
-
-
-class ManifestError(Exception):
-    """Base exception for coreason_manifest errors."""
-
-    pass
-
-
-class ManifestSyntaxError(ManifestError):
-    """Raised when the manifest YAML is invalid or missing required fields.
-
-    This includes YAML parsing errors and JSON Schema validation failures.
-    """
-
-    pass
-
-
-class PolicyViolationError(ManifestError):
-    """Raised when the agent violates a compliance policy.
-
-    This error indicates that the manifest is structurally valid but fails
-    business rules or compliance checks (e.g., banned libraries).
-
-    Attributes:
-        violations: A list of specific policy violation messages.
-    """
-
-    def __init__(self, message: str, violations: list[str] | None = None) -> None:
-        """Initialize PolicyViolationError.
-
-        Args:
-            message: The error message.
-            violations: Optional list of detailed violation strings.
-        """
-        super().__init__(message)
-        self.violations = violations or []
-
-
-class IntegrityCompromisedError(ManifestError):
-    """Raised when the source code hash does not match the manifest.
-
-    This indicates that the source code may have been tampered with or changed
-    without updating the manifest's integrity hash.
-    """
-
-    pass

coreason_manifest-0.6.0/src/coreason_manifest/integrity.py

@@ -1,141 +0,0 @@
-# Prosperity-3.0
-"""Integrity checking functionality.
-
-This module provides the `IntegrityChecker` class, which is responsible for
-calculating deterministic hashes of source code directories and verifying
-them against the expected hash in the agent manifest.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import os
-from pathlib import Path
-from typing import List, Optional, Set, Union
-
-from coreason_manifest.errors import IntegrityCompromisedError
-from coreason_manifest.models import AgentDefinition
-
-
-class IntegrityChecker:
-    """Component D: IntegrityChecker (The Notary).
-
-    Responsibility:
-      - Calculate the SHA256 hash of the source code directory.
-      - Compare it against the integrity_hash defined in the manifest.
-    """
-
-    IGNORED_DIRS = frozenset({".git", "__pycache__", ".venv", ".env", ".DS_Store"})
-
-    @staticmethod
-    def calculate_hash(source_dir: Union[Path, str], exclude_files: Optional[Set[Union[Path, str]]] = None) -> str:
-        """Calculates a deterministic SHA256 hash of the source code directory.
-
-        It walks the directory using os.walk to efficiently prune ignored directories.
-        Sorts files by relative path, hashes each file, and then hashes the sequence.
-
-        Ignores hidden directories/files in IGNORED_DIRS.
-        Rejects symbolic links for security.
-
-        Args:
-            source_dir: The directory containing source code.
-            exclude_files: Optional set of file paths (absolute or relative to CWD)
-                to exclude from hashing.
-
-        Returns:
-            The hex digest of the SHA256 hash.
-
-        Raises:
-            FileNotFoundError: If source_dir does not exist.
-            IntegrityCompromisedError: If a symlink is found.
-        """
-        path_obj = Path(source_dir)
-        if path_obj.is_symlink():
-            raise IntegrityCompromisedError(f"Symbolic links are forbidden: {path_obj}")
-
-        source_path = path_obj.resolve()
-        if not source_path.exists():
-            raise FileNotFoundError(f"Source directory not found: {source_path}")
-
-        # Normalize excluded files to absolute paths
-        excludes = set()
-        if exclude_files:
-            for ex_path in exclude_files:
-                excludes.add(Path(ex_path).resolve())
-
-        sha256 = hashlib.sha256()
-        file_paths: List[Path] = []
-
-        # Use os.walk for efficient traversal and pruning
-        for root, dirs, files in os.walk(source_path, topdown=True):
-            root_path = Path(root)
-
-            # Check for symlinks in directories before pruning
-            for d_name in dirs:
-                d_path = root_path / d_name
-                if d_path.is_symlink():
-                    raise IntegrityCompromisedError(f"Symbolic links are forbidden: {d_path}")  # pragma: no cover
-
-            # Prune directories efficiently using slice assignment
-            dirs[:] = [d for d in dirs if d not in IntegrityChecker.IGNORED_DIRS]
-
-            # Collect files
-            for f_name in files:
-                f_path = root_path / f_name
-
-                if f_path.is_symlink():
-                    raise IntegrityCompromisedError(f"Symbolic links are forbidden: {f_path}")
-
-                if f_name in IntegrityChecker.IGNORED_DIRS:
-                    continue
-
-                # Use resolved path for exclusion checking and inclusion
-                f_path_abs = f_path.resolve()
-                if f_path_abs in excludes:
-                    continue
-
-                file_paths.append(f_path_abs)
-
-        # Sort to ensure deterministic order
-        # Use as_posix() to ensure ASCII sorting (case-sensitive) on all platforms (Windows vs Linux)
-        file_paths.sort(key=lambda p: p.relative_to(source_path).as_posix())
-
-        for path in file_paths:
-            # Update hash with relative path to ensure structure matters
-            # Use forward slashes for cross-platform consistency
-            rel_path = path.relative_to(source_path).as_posix().encode("utf-8")
-            sha256.update(rel_path)
-
-            # Update hash with file content
-            with open(path, "rb") as f:
-                while chunk := f.read(8192):
-                    sha256.update(chunk)
-
-        return sha256.hexdigest()
-
-    @staticmethod
-    def verify(
-        agent_def: AgentDefinition,
-        source_dir: Union[Path, str],
-        manifest_path: Optional[Union[Path, str]] = None,
-    ) -> None:
-        """Verifies the integrity of the source code against the manifest.
-
-        Args:
-            agent_def: The AgentDefinition containing the expected hash.
-            source_dir: The directory containing source code.
-            manifest_path: Optional path to the manifest file to exclude from hashing.
-
-        Raises:
-            IntegrityCompromisedError: If the hash does not match or is missing.
-            FileNotFoundError: If source_dir does not exist.
-        """
-        exclude_files = {manifest_path} if manifest_path else None
-
-        # agent_def.integrity_hash is now required by Pydantic model
-        calculated = IntegrityChecker.calculate_hash(source_dir, exclude_files=exclude_files)
-
-        if calculated != agent_def.integrity_hash:
-            raise IntegrityCompromisedError(
-                f"Integrity check failed. Expected {agent_def.integrity_hash}, got {calculated}"
-            )