Fix the failing test from its log. Public repository OmniNode-ai/omnibase_core, snapshot a3ee0cdd6ced443d1234f071d4cd48fad79df778.
Return only a unified diff for src/omnibase_core/models/delegation/model_remote_task_state.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/delegation/test_delegation_extra_forbid.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 13 items

tests/unit/models/delegation/test_delegation_extra_forbid.py [32m.[0m[32m.[0m[32m.[0m[32m.[0m[31mF[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[31mF[0m[31m [ 84%]
[0m[32m.[0m[32m.[0m[31m                                                                       [100%][0m

=================================== FAILURES ===================================
[31m[1m____ test_unknown_field_is_rejected_at_each_boundary[ModelRemoteTaskState] _____[0m
[1m[31mtests/unit/models/delegation/test_delegation_extra_forbid.py[0m:121: in test_unknown_field_is_rejected_at_each_boundary
    [0m[94mwith[39;49;00m pytest.raises(ValidationError) [94mas[39;49;00m mapping_error:[90m[39;49;00m
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mE   Failed: DID NOT RAISE <class 'pydantic_core._pydantic_core.ValidationError'>[0m
[31m[1m_______ test_valid_payload_parses_at_each_boundary[ModelRemoteTaskState] _______[0m
[1m[31mtests/unit/models/delegation/test_delegation_extra_forbid.py[0m:109: in test_valid_payload_parses_at_each_boundary
    [0m[94massert[39;49;00m model.model_json_schema()[[33m"[39;49;00m[33madditionalProperties[39;49;00m[33m"[39;49;00m] [95mis[39;49;00m [94mFalse[39;49;00m[90m[39;49;00m
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mE   KeyError: 'additionalProperties'[0m
[36m[1m=========================== short test summary info ============================[0m
[31mFAILED[0m tests/unit/models/delegation/test_delegation_extra_forbid.py::[1mtest_unknown_field_is_rejected_at_each_boundary[ModelRemoteTaskState][0m - Failed: DID NOT RAISE <class 'pydantic_core._pydantic_core.ValidationError'>
[31mFAILED[0m tests/unit/models/delegation/test_delegation_extra_forbid.py::[1mtest_valid_payload_parses_at_each_boundary[ModelRemoteTaskState][0m - KeyError: 'additionalProperties'
[31m========================= [31m[1m2 failed[0m, [32m11 passed[0m[31m in 0.40s[0m[31m =========================[0m


Current faulty source src/omnibase_core/models/delegation/model_remote_task_state.py:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT
"""ModelRemoteTaskState: durable state for restart-safe remote task resumption (OMN-9637)."""

from __future__ import annotations

from datetime import datetime
from uuid import UUID

from pydantic import BaseModel, ConfigDict, model_validator

from omnibase_core.enums.enum_agent_protocol import EnumAgentProtocol
from omnibase_core.enums.enum_agent_task_lifecycle_type import (
    EnumAgentTaskLifecycleType,
)
from omnibase_core.enums.enum_invocation_kind import EnumInvocationKind


class ModelRemoteTaskState(BaseModel):
    """Persisted state for a remote agent task invocation.

    Rows are created and updated by node_remote_agent_invoke_effect.
    Used to resume unfinished remote tasks after service restart.
    """

    model_config = ConfigDict(frozen=True)

    task_id: UUID
    invocation_kind: EnumInvocationKind
    protocol: EnumAgentProtocol | None = None
    target_ref: str
    remote_task_handle: str | None = None
    correlation_id: UUID
    status: EnumAgentTaskLifecycleType
    last_remote_status: str | None = None
    last_emitted_event_type: EnumAgentTaskLifecycleType | None = None
    submitted_at: datetime
    updated_at: datetime
    completed_at: datetime | None = None
    error: str | None = None

    @model_validator(mode="after")
    def _validate_protocol_for_kind(self) -> ModelRemoteTaskState:
        if self.invocation_kind is EnumInvocationKind.AGENT and self.protocol is None:
            msg = "protocol is required when invocation_kind is AGENT"
            raise ValueError(msg)
        return self


__all__ = ["ModelRemoteTaskState"]

```
Unchanged test source:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT
"""Unknown-field rejection at audited delegation boundaries (OMN-20188)."""

from __future__ import annotations

import json

import pytest
from pydantic import BaseModel, ValidationError

from omnibase_core.models.common.model_schema_value import ModelSchemaValue
from omnibase_core.models.delegation.model_a2a_task_request import ModelA2ATaskRequest
from omnibase_core.models.delegation.model_a2a_task_response import ModelA2ATaskResponse
from omnibase_core.models.delegation.model_remote_task_state import ModelRemoteTaskState
from omnibase_core.models.delegation.model_routing_rule import ModelRoutingRule
from omnibase_core.models.delegation.model_target_agent import ModelTargetAgent
from omnibase_core.models.governance.model_delegation_health import (
    ModelDelegationHealth,
)
from omnibase_core.models.governance.model_dogfood_scorecard import (
    ModelDogfoodScorecard,
)

_TASK_ID = "aaaaaaaa-0000-0000-0000-000000000001"
_CORRELATION_ID = "bbbbbbbb-0000-0000-0000-000000000002"
_TIMESTAMP = "2026-04-25T12:00:00Z"
_SCHEMA_VALUE = ModelSchemaValue.from_value("triage these").model_dump(mode="json")
_HEALTH_PAYLOAD: dict[str, object] = {
    "task_type_coverage": {"triage": "pass", "research": "warn"},
    "classifier_coverage_pct": 95.0,
    "model_health": "pass",
    "status": "warn",
}

_CASES: tuple[tuple[type[BaseModel], dict[str, object]], ...] = (
    (
        ModelA2ATaskRequest,
        {
            "skill_ref": "scout",
            "input": {"prompt": _SCHEMA_VALUE},
            "correlation_id": _CORRELATION_ID,
        },
    ),
    (
        ModelA2ATaskResponse,
        {
            "remote_task_handle": "task-123",
            "status": "COMPLETED",
            "artifacts": [{"result": _SCHEMA_VALUE}],
            "error": None,
        },
    ),
    (
        ModelRemoteTaskState,
        {
            "task_id": _TASK_ID,
            "invocation_kind": "agent",
            "protocol": "A2A",
            "target_ref": "scout",
            "remote_task_handle": "task-123",
            "correlation_id": _CORRELATION_ID,
            "status": "COMPLETED",
            "last_remote_status": "completed",
            "last_emitted_event_type": "COMPLETED",
            "submitted_at": _TIMESTAMP,
            "updated_at": _TIMESTAMP,
            "completed_at": _TIMESTAMP,
            "error": None,
        },
    ),
    (
        ModelRoutingRule,
        {
            "capability": "tech_debt_triage",
            "invocation_kind": "agent",
            "agent_protocol": "A2A",
            "model_backend": None,
            "target_ref": "scout",
            "fallbacks": ["backup-scout"],
        },
    ),
    (
        ModelTargetAgent,
        {
            "target_ref": "scout",
            "base_url": "http://localhost:9080",
            "protocol": "A2A",
        },
    ),
    (ModelDelegationHealth, _HEALTH_PAYLOAD),
)


@pytest.mark.unit
@pytest.mark.parametrize(
    ("model", "payload"), _CASES, ids=[model.__name__ for model, _ in _CASES]
)
def test_valid_payload_parses_at_each_boundary(
    model: type[BaseModel], payload: dict[str, object]
) -> None:
    """Declared fields, including open content maps, survive wire round trips."""
    parsed = model.model_validate(payload)
    assert parsed == model.model_validate_json(json.dumps(payload))
    assert parsed == model(**payload)
    assert model.model_validate_json(parsed.model_dump_json()) == parsed
    assert set(payload) <= parsed.model_fields_set
    assert model.model_config["frozen"] is True
    assert model.model_json_schema()["additionalProperties"] is False


@pytest.mark.unit
@pytest.mark.parametrize(
    ("model", "payload"), _CASES, ids=[model.__name__ for model, _ in _CASES]
)
def test_unknown_field_is_rejected_at_each_boundary(
    model: type[BaseModel], payload: dict[str, object]
) -> None:
    """Schema skew must fail with an extra_forbidden error at the unknown key."""
    bad_payload = {**payload, "unexpected_wire_field": True}
    with pytest.raises(ValidationError) as mapping_error:
        model.model_validate(bad_payload)
    with pytest.raises(ValidationError) as json_error:
        model.model_validate_json(json.dumps(bad_payload))
    with pytest.raises(ValidationError) as constructor_error:
        model(**bad_payload)

    for error in (mapping_error, json_error, constructor_error):
        assert [(item["type"], item["loc"]) for item in error.value.errors()] == [
            ("extra_forbidden", ("unexpected_wire_field",))
        ]


@pytest.mark.unit
def test_scorecard_validates_nested_delegation_health() -> None:
    payload = {
        "captured_at": _TIMESTAMP,
        "run_id": "delegation-audit",
        "overall_status": "warn",
        "delegation": _HEALTH_PAYLOAD,
    }
    scorecard = ModelDogfoodScorecard.model_validate(payload)
    assert scorecard.delegation == ModelDelegationHealth.model_validate(_HEALTH_PAYLOAD)
    assert ModelDogfoodScorecard.model_validate_json(json.dumps(payload)) == scorecard

    payload["delegation"] = {**_HEALTH_PAYLOAD, "unexpected_wire_field": True}
    with pytest.raises(ValidationError) as mapping_error:
        ModelDogfoodScorecard.model_validate(payload)
    with pytest.raises(ValidationError) as json_error:
        ModelDogfoodScorecard.model_validate_json(json.dumps(payload))

    for error in (mapping_error, json_error):
        assert [(item["type"], item["loc"]) for item in error.value.errors()] == [
            ("extra_forbidden", ("delegation", "unexpected_wire_field"))
        ]

```
