Fix the failing test from its log. Public repository OmniNode-ai/omnibase_core, snapshot f5cf4e1a027b13308bca8d81346956b7f478ef23.
Return only a unified diff for src/omnibase_core/models/node_metadata/model_node_core_metadata_class.py; do not change any test, contract, configuration, dependency or other file. The regression was seeded by restoring this product source file to the parent of a recent fix commit. Do not assume access to a workspace. Preserve existing behavior and strong UUID types.
The unchanged test command is: pytest tests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py -q --tb=short
Failing test log:
[1m============================= test session starts ==============================[0m
platform darwin -- Python 3.13.12, pytest-9.0.3, pluggy-1.6.0
rootdir: fixture-root
configfile: pytest.ini
plugins: hypothesis-6.151.6, mock-3.15.1, locust-2.43.3, xdist-3.8.0, split-0.11.0, timeout-2.4.0, cov-6.3.0, anyio-4.14.2, pytest_httpserver-1.1.5, asyncio-1.3.0
asyncio: mode=Mode.STRICT, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collected 4 items

tests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py [31mF[0m[31m [ 25%]
[0m[31mF[0m[31mF[0m[31mF[0m[31m                                                                      [100%][0m

=================================== FAILURES ===================================
[31m[1m________ test_node_core_metadata_validates_and_round_trips_typed_semver ________[0m
[1m[31mtests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py[0m:63: in test_node_core_metadata_validates_and_round_trips_typed_semver
    [0mmetadata = ModelNodeCoreMetadata.model_validate(payload)[90m[39;49;00m
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mE   pydantic.errors.PydanticUserError: `ModelNodeCoreMetadata` is not fully defined; you should define `ModelSemVer`, then call `ModelNodeCoreMetadata.model_rebuild()`.[0m
[1m[31mE   [0m
[1m[31mE   For further information visit https://errors.pydantic.dev/2.13/u/class-not-fully-defined[0m
[31m[1m_ test_node_introspection_schema_is_complete_in_both_fresh_import_orders[omnibase_core.models.common.model_numeric_value] _[0m
[1m[31mtests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py[0m:46: in test_node_introspection_schema_is_complete_in_both_fresh_import_orders
    [0msubprocess.run([90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/subprocess.py[0m:577: in run
    [0m[94mraise[39;49;00m CalledProcessError(retcode, process.args,[90m[39;49;00m
[1m[31mE   subprocess.CalledProcessError: Command '['fixture-root', '-c', '\nimport importlib\nimport sys\n\nimportlib.import_module(sys.argv[1])\nfrom omnibase_core.models.core.model_node_introspection_response import ModelNodeIntrospectionResponse\nfrom omnibase_core.models.node_metadata.model_node_core_metadata_class import ModelNodeCoreMetadata\nfrom omnibase_core.models.node_metadata.model_node_metadata_info import ModelNodeMetadataInfo\n\nassert ModelNodeCoreMetadata.__pydantic_complete__\nassert ModelNodeMetadataInfo.__pydantic_complete__\nassert ModelNodeIntrospectionResponse.__pydantic_complete__\nassert ModelNodeIntrospectionResponse.model_json_schema()["type"] == "object"\n', 'omnibase_core.models.common.model_numeric_value']' returned non-zero exit status 1.[0m
[31m[1m_ test_node_introspection_schema_is_complete_in_both_fresh_import_orders[omnibase_core.models.core.model_node_introspection_response] _[0m
[1m[31mtests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py[0m:46: in test_node_introspection_schema_is_complete_in_both_fresh_import_orders
    [0msubprocess.run([90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/subprocess.py[0m:577: in run
    [0m[94mraise[39;49;00m CalledProcessError(retcode, process.args,[90m[39;49;00m
[1m[31mE   subprocess.CalledProcessError: Command '['fixture-root', '-c', '\nimport importlib\nimport sys\n\nimportlib.import_module(sys.argv[1])\nfrom omnibase_core.models.core.model_node_introspection_response import ModelNodeIntrospectionResponse\nfrom omnibase_core.models.node_metadata.model_node_core_metadata_class import ModelNodeCoreMetadata\nfrom omnibase_core.models.node_metadata.model_node_metadata_info import ModelNodeMetadataInfo\n\nassert ModelNodeCoreMetadata.__pydantic_complete__\nassert ModelNodeMetadataInfo.__pydantic_complete__\nassert ModelNodeIntrospectionResponse.__pydantic_complete__\nassert ModelNodeIntrospectionResponse.model_json_schema()["type"] == "object"\n', 'omnibase_core.models.core.model_node_introspection_response']' returned non-zero exit status 1.[0m
[31m[1m____ test_node_metadata_schema_rebuild_is_repeatedly_concurrent_and_stable _____[0m
[1m[31mtests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py[0m:90: in test_node_metadata_schema_rebuild_is_repeatedly_concurrent_and_stable
    [0mobservations = [96mlist[39;49;00m(executor.map([94mlambda[39;49;00m _: read_schema(), [96mrange[39;49;00m([94m16[39;49;00m)))[90m[39;49;00m
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/concurrent/futures/_base.py[0m:619: in result_iterator
    [0m[94myield[39;49;00m _result_or_cancel(fs.pop())[90m[39;49;00m
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/concurrent/futures/_base.py[0m:317: in _result_or_cancel
    [0m[94mreturn[39;49;00m fut.result(timeout)[90m[39;49;00m
           ^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/concurrent/futures/_base.py[0m:449: in result
    [0m[94mreturn[39;49;00m [96mself[39;49;00m.__get_result()[90m[39;49;00m
           ^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/concurrent/futures/_base.py[0m:401: in __get_result
    [0m[94mraise[39;49;00m [96mself[39;49;00m._exception[90m[39;49;00m
[1m[31m/opt/homebrew/Cellar/python@3.13/3.13.12_1/Frameworks/Python.framework/Versions/3.13/lib/python3.13/concurrent/futures/thread.py[0m:59: in run
    [0mresult = [96mself[39;49;00m.fn(*[96mself[39;49;00m.args, **[96mself[39;49;00m.kwargs)[90m[39;49;00m
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mtests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py[0m:90: in <lambda>
    [0mobservations = [96mlist[39;49;00m(executor.map([94mlambda[39;49;00m _: read_schema(), [96mrange[39;49;00m([94m16[39;49;00m)))[90m[39;49;00m
                                               ^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mtests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py[0m:81: in read_schema
    [0mschema = ModelNodeIntrospectionResponse.model_json_schema()[90m[39;49;00m
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31m../../../.onex-dispatch-venv/lib/python3.13/site-packages/pydantic/main.py[0m:591: in model_json_schema
    [0m[94mreturn[39;49;00m model_json_schema([90m[39;49;00m
[1m[31m../../../.onex-dispatch-venv/lib/python3.13/site-packages/pydantic/json_schema.py[0m:2557: in model_json_schema
    [0m[96mcls[39;49;00m.__pydantic_core_schema__.rebuild()[90m[39;49;00m
[1m[31m../../../.onex-dispatch-venv/lib/python3.13/site-packages/pydantic/_internal/_mock_val_ser.py[0m:67: in rebuild
    [0m[94mraise[39;49;00m PydanticUserError([96mself[39;49;00m._error_message, code=[96mself[39;49;00m._code)[90m[39;49;00m
[1m[31mE   pydantic.errors.PydanticUserError: `ModelNodeIntrospectionResponse` is not fully defined; you should define `ModelSemVer`, then call `ModelNodeIntrospectionResponse.model_rebuild()`.[0m
[1m[31mE   [0m
[1m[31mE   For further information visit https://errors.pydantic.dev/2.13/u/class-not-fully-defined[0m
[36m[1m=========================== short test summary info ============================[0m
[31mFAILED[0m tests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py::[1mtest_node_core_metadata_validates_and_round_trips_typed_semver[0m - pydantic.errors.PydanticUserError: `ModelNodeCoreMetadata` is not fully def...
[31mFAILED[0m tests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py::[1mtest_node_introspection_schema_is_complete_in_both_fresh_import_orders[omnibase_core.models.common.model_numeric_value][0m - subprocess.CalledProcessError: Command '['fixture-root
[31mFAILED[0m tests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py::[1mtest_node_introspection_schema_is_complete_in_both_fresh_import_orders[omnibase_core.models.core.model_node_introspection_response][0m - subprocess.CalledProcessError: Command '['fixture-root
[31mFAILED[0m tests/unit/models/node_metadata/test_omn17735_node_metadata_runtime_semver.py::[1mtest_node_metadata_schema_rebuild_is_repeatedly_concurrent_and_stable[0m - pydantic.errors.PydanticUserError: `ModelNodeIntrospectionResponse` is not ...
[31m============================== [31m[1m4 failed[0m[31m in 3.09s[0m[31m ===============================[0m


Current faulty source src/omnibase_core/models/node_metadata/model_node_core_metadata_class.py:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT

"""
Node Core Metadata Model.

Core node metadata with essential identification and status information.
"""

from typing import TYPE_CHECKING
from uuid import UUID, uuid4

from pydantic import BaseModel, ConfigDict, Field

from omnibase_core.enums.enum_health_status import EnumHealthStatus
from omnibase_core.enums.enum_metadata_node_status import EnumMetadataNodeStatus
from omnibase_core.enums.enum_metadata_node_type import EnumMetadataNodeType
from omnibase_core.types import TypedDictMetadataDict, TypedDictSerializedModel

if TYPE_CHECKING:
    from omnibase_core.models.primitives.model_semver import ModelSemVer


class ModelNodeCoreMetadata(BaseModel):
    """
    Core node metadata with essential identification.

    Contains only the most critical node information:
    - Identity (ID, name, type)
    - Status and health
    - Version information
    Implements Core protocols:
    - Identifiable: UUID-based identification
    - ProtocolMetadataProvider: Metadata management capabilities
    - Serializable: Data serialization/deserialization
    - Validatable: Validation and verification
    """

    # Core identification - UUID-based entity references
    node_id: UUID = Field(
        default_factory=uuid4,
        description="Unique identifier for the node entity",
    )
    node_display_name: str = Field(default="", description="Human-readable node name")
    node_type: EnumMetadataNodeType = Field(default=..., description="Node type")

    # Status information (2 fields)
    status: EnumMetadataNodeStatus = Field(
        default=EnumMetadataNodeStatus.ACTIVE,
        description="Node status",
    )
    health: EnumHealthStatus = Field(
        default=EnumHealthStatus.HEALTHY,
        description="Node health",
    )

    # Version (1 field, but structured)
    version: "ModelSemVer | None" = Field(default=None, description="Node version")

    def is_active(self) -> bool:
        """Check if node is active."""
        return self.status == EnumMetadataNodeStatus.ACTIVE

    def is_healthy(self) -> bool:
        """Check if node is healthy."""
        return self.health == EnumHealthStatus.HEALTHY

    def get_status_summary(self) -> dict[str, str]:
        """Get concise status summary."""
        return {
            "status": self.status.value,
            "health": self.health.value,
            "version": str(self.version) if self.version else "unknown",
        }

    @property
    def node_name(self) -> str:
        """Get node name with fallback to UUID-based name."""
        return self.node_display_name or f"node_{str(self.node_id)[:8]}"

    @node_name.setter
    def node_name(self, value: str) -> None:
        """Set node name."""
        self.node_display_name = value

    @classmethod
    def create_simple(
        cls,
        node_name: str,
        node_type: EnumMetadataNodeType = EnumMetadataNodeType.FUNCTION,
    ) -> "ModelNodeCoreMetadata":
        """Create simple core metadata with deterministic UUID."""
        from uuid import NAMESPACE_DNS, uuid5

        # Generate deterministic UUID from node name
        node_id = uuid5(NAMESPACE_DNS, node_name)
        return cls(
            node_id=node_id,
            node_display_name=node_name,
            node_type=node_type,
        )

    model_config = ConfigDict(
        extra="ignore",
        use_enum_values=False,
        validate_assignment=True,
    )

    # Protocol method implementations

    def get_id(self) -> str:
        """Get unique identifier (Identifiable protocol)."""
        # Try common ID field patterns
        for field in [
            "id",
            "uuid",
            "identifier",
            "node_id",
            "execution_id",
            "metadata_id",
        ]:
            if hasattr(self, field):
                value = getattr(self, field)
                if value is not None:
                    return str(value)

        from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
        from omnibase_core.models.errors.model_onex_error import ModelOnexError

        raise ModelOnexError(
            error_code=EnumCoreErrorCode.VALIDATION_ERROR,
            message=f"{self.__class__.__name__} must have a valid ID field "
            f"(type_id, id, uuid, identifier, etc.). "
            f"Cannot generate stable ID without UUID field.",
        )

    def get_metadata(self) -> TypedDictMetadataDict:
        """Get metadata as dictionary (ProtocolMetadataProvider protocol)."""
        result: TypedDictMetadataDict = {}
        # Map actual fields to TypedDictMetadataDict structure
        # node_name property always returns non-empty (has UUID fallback)
        result["name"] = self.node_name
        if self.version:
            result["version"] = self.version
        # Pack additional fields into metadata
        result["metadata"] = {
            "node_id": str(self.node_id),
            "node_type": self.node_type.value,
            "status": self.status.value,
            "health": self.health.value,
            "is_active": self.is_active(),
            "is_healthy": self.is_healthy(),
        }
        return result

    def set_metadata(self, metadata: TypedDictMetadataDict) -> bool:
        """Set metadata from dictionary (ProtocolMetadataProvider protocol)."""
        try:
            for key, value in metadata.items():
                if hasattr(self, key):
                    setattr(self, key, value)
            return True
        except (
            Exception  # noqa: BLE001
        ):  # fallback-ok: setter returns False on failure per protocol contract
            return False

    def serialize(self) -> TypedDictSerializedModel:
        """Serialize to dictionary (Serializable protocol)."""
        return self.model_dump(exclude_none=False, by_alias=True)

    def validate_instance(self) -> bool:
        """Validate instance integrity (ProtocolValidatable protocol)."""
        # Basic validation - ensure required fields exist
        # Override in specific models for custom validation
        return True

```
Unchanged test source:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT

"""Regression coverage for the node-metadata SemVer runtime boundary."""

from __future__ import annotations

import subprocess
import sys
from concurrent.futures import ThreadPoolExecutor

import pytest

from omnibase_core.enums.enum_metadata_node_type import EnumMetadataNodeType
from omnibase_core.models.node_metadata.model_node_core_metadata_class import (
    ModelNodeCoreMetadata,
)


@pytest.mark.unit
@pytest.mark.parametrize(
    "first_module",
    [
        "omnibase_core.models.common.model_numeric_value",
        "omnibase_core.models.core.model_node_introspection_response",
    ],
)
def test_node_introspection_schema_is_complete_in_both_fresh_import_orders(
    first_module: str,
) -> None:
    """A valid import order must not leave the nested SemVer graph incomplete."""
    probe = """
import importlib
import sys

importlib.import_module(sys.argv[1])
from omnibase_core.models.core.model_node_introspection_response import ModelNodeIntrospectionResponse
from omnibase_core.models.node_metadata.model_node_core_metadata_class import ModelNodeCoreMetadata
from omnibase_core.models.node_metadata.model_node_metadata_info import ModelNodeMetadataInfo

assert ModelNodeCoreMetadata.__pydantic_complete__
assert ModelNodeMetadataInfo.__pydantic_complete__
assert ModelNodeIntrospectionResponse.__pydantic_complete__
assert ModelNodeIntrospectionResponse.model_json_schema()["type"] == "object"
"""
    subprocess.run(
        [sys.executable, "-c", probe, first_module],
        check=True,
        text=True,
        capture_output=True,
    )


@pytest.mark.unit
def test_node_core_metadata_validates_and_round_trips_typed_semver() -> None:
    """The repaired runtime import preserves the existing typed SemVer wire contract."""
    payload: dict[str, object] = {
        "node_display_name": "test-node",
        "node_type": EnumMetadataNodeType.FUNCTION.value,
        "version": {"major": 1, "minor": 2, "patch": 3},
    }

    metadata = ModelNodeCoreMetadata.model_validate(payload)
    restored = ModelNodeCoreMetadata.model_validate_json(metadata.model_dump_json())

    assert str(metadata.version) == "1.2.3"
    assert restored == metadata


@pytest.mark.unit
def test_node_metadata_schema_rebuild_is_repeatedly_concurrent_and_stable() -> None:
    """Concurrent callers observe a complete immutable schema graph."""
    from omnibase_core.models.core.model_node_introspection_response import (
        ModelNodeIntrospectionResponse,
    )
    from omnibase_core.models.node_metadata.model_node_metadata_info import (
        ModelNodeMetadataInfo,
    )

    def read_schema() -> tuple[bool, bool, bool, str]:
        schema = ModelNodeIntrospectionResponse.model_json_schema()
        return (
            ModelNodeCoreMetadata.__pydantic_complete__,
            ModelNodeMetadataInfo.__pydantic_complete__,
            ModelNodeIntrospectionResponse.__pydantic_complete__,
            schema["type"],
        )

    with ThreadPoolExecutor(max_workers=4) as executor:
        observations = list(executor.map(lambda _: read_schema(), range(16)))

    assert observations == [(True, True, True, "object")] * 16

```
