Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

32.6 KB
Raw Blame
"""TaskInteractionRequest constraint-behavior and shape sentinels (PostgreSQL half).

Companion to test_task_interaction_schema.py; see that file's and
task_interaction_schema_shared.py's module docstrings for the full
rationale behind each invariant pinned here, the backend split, and the
UNIQUE-violation message asymmetry. Docstrings below are intentionally
short and point back to the SQLite half rather than repeat it. Fixture
pattern copied from test_task_status_storage_postgresql.py /
test_runtime_key_transition_postgres.py (skip-if-unset via
XAGENT_TEST_POSTGRES_URL).
"""

from __future__ import annotations

import os
from datetime import datetime, timedelta, timezone

import pytest
from sqlalchemy import DateTime, inspect, text
from sqlalchemy.exc import IntegrityError

from tests.web.services.task_interaction_schema_shared import (
    EXPECTED_CHECK_CONSTRAINT_NAMES,
    EXPECTED_COLUMNS,
    EXPECTED_FOREIGN_KEYS,
    EXPECTED_NONUNIQUE_INDEXES,
    EXPECTED_NULLABLE,
    EXPECTED_STRING_LENGTHS,
    EXPECTED_UNIQUE_CONSTRAINTS,
    TIMESTAMP_COLUMNS,
    assert_accepted,
    assert_rejected,
    assert_update_accepted,
    assert_update_rejected,
    make_row,
    make_task,
    make_trace_event,
    make_user,
)
from xagent.web.models.database import Base, get_db, get_engine, init_db
from xagent.web.models.task import Task, TraceEvent
from xagent.web.models.task_interaction import TaskInteractionRequest
from xagent.web.models.user import User


@pytest.fixture()
def db_session():
    """Isolated TaskInteractionRequest rows in a real PostgreSQL test
    database. Fails closed rather than pointing at whatever XAGENT_TEST_
    POSTGRES_URL happens to resolve to: this is the same drop_all/create_all
    of the *entire* Base.metadata that every PostgreSQL suite following this
    pattern already does, so the URL must name a database whose full schema
    this suite is allowed to drop and recreate.
    """
    url = os.getenv("XAGENT_TEST_POSTGRES_URL")
    if not url:
        pytest.skip("XAGENT_TEST_POSTGRES_URL is not set")
    init_db(db_url=url)
    engine = get_engine()
    Base.metadata.drop_all(bind=engine)
    Base.metadata.create_all(bind=engine)
    db = next(get_db())
    try:
        yield db
    finally:
        db.close()
        Base.metadata.drop_all(bind=engine)


@pytest.fixture()
def fixtures(db_session):
    """A (task_id, anchor_trace_event_id) pair shared by most tests below."""
    user_id = make_user(db_session)
    task_id = make_task(db_session, user_id=user_id)
    anchor_id = make_trace_event(db_session, task_id=task_id)
    return task_id, anchor_id


# --------------------------------------------------------------------------
# T-uq: uniqueness (3 active-slot + 2 identity)
# --------------------------------------------------------------------------


def test_active_slot_unique_rejects_second_active_row(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    assert_rejected(
        db_session,
        make_row(task_id=task_id, resume_trace_event_id=anchor_id),
        "uq_task_interaction_active_slot",
    )


def test_active_slot_null_is_distinct_across_terminal_rows(
    db_session, fixtures
) -> None:
    """Also the sentinel against NULLS NOT DISTINCT ever being added to
    uq_task_interaction_active_slot -- see the SQLite half and the model's
    class docstring.
    """
    task_id, anchor_id = fixtures
    for _ in range(3):
        assert_accepted(
            db_session,
            make_row(
                task_id=task_id, resume_trace_event_id=anchor_id, status="terminated"
            ),
        )


def test_active_slot_unique_is_scoped_per_task(db_session) -> None:
    user_id = make_user(db_session)
    task_a = make_task(db_session, user_id=user_id)
    task_b = make_task(db_session, user_id=user_id)
    anchor_a = make_trace_event(db_session, task_id=task_a)
    anchor_b = make_trace_event(db_session, task_id=task_b)
    assert_accepted(
        db_session, make_row(task_id=task_a, resume_trace_event_id=anchor_a)
    )
    assert_accepted(
        db_session, make_row(task_id=task_b, resume_trace_event_id=anchor_b)
    )


def test_identity_unique_rejects_same_task_run_key(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            run_id="run-dup",
            request_idempotency_key="key-dup",
        ),
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            run_id="run-dup",
            request_idempotency_key="key-dup",
        ),
        "uq_task_interaction_request_identity",
    )


def test_identity_unique_is_run_scoped(db_session, fixtures) -> None:
    """Run-scoping: the same (task_id, key) is allowed across different
    run_id values."""
    task_id, anchor_id = fixtures
    assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            run_id="run-1",
            request_idempotency_key="key-shared",
        ),
    )
    assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            run_id="run-2",
            request_idempotency_key="key-shared",
        ),
    )


# --------------------------------------------------------------------------
# T-ck-1..6: vocabulary CHECKs
# --------------------------------------------------------------------------


def test_status_rejects_unknown_literal(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    row = make_row(
        task_id=task_id,
        resume_trace_event_id=anchor_id,
        status="bogus",
        active_slot=None,
    )
    assert_rejected(db_session, row, "ck_task_interaction_requests_status")


def test_kind_rejects_unknown_literal(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    row = make_row(
        task_id=task_id, resume_trace_event_id=anchor_id, kind="unknown_kind"
    )
    assert_rejected(db_session, row, "ck_task_interaction_requests_kind")


@pytest.mark.parametrize(
    "origin", ["internal", "sdk", "a2a", "trigger", "widget", "shared_link"]
)
def test_origin_accepts_every_vocabulary_member(db_session, fixtures, origin) -> None:
    """Every member of the origin vocabulary is accepted -- see the SQLite
    half."""
    task_id, anchor_id = fixtures
    assert_accepted(
        db_session,
        make_row(task_id=task_id, resume_trace_event_id=anchor_id, origin=origin),
    )


def test_origin_rejects_unknown_literal(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    row = make_row(task_id=task_id, resume_trace_event_id=anchor_id, origin="email")
    assert_rejected(db_session, row, "ck_task_interaction_requests_origin")


def test_resume_checkpoint_type_and_locator_format_reject_unknown(
    db_session, fixtures
) -> None:
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            resume_checkpoint_type="unknown_checkpoint_type",
        ),
        "ck_task_interaction_requests_resume_checkpoint_type",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            resume_locator_format="unknown_locator_format",
        ),
        "ck_task_interaction_requests_resume_locator_format",
    )


def test_terminal_reason_vocabulary(db_session, fixtures) -> None:
    """Rename regression guard -- see the SQLite half."""
    task_id, anchor_id = fixtures
    for reason in ("deadline_elapsed", "run_superseded", "answered_via_legacy_resume"):
        assert_accepted(
            db_session,
            make_row(
                task_id=task_id,
                resume_trace_event_id=anchor_id,
                status="terminated",
                terminal_reason=reason,
            ),
        )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            terminal_reason="superseded_by_legacy_resume",
        ),
        "ck_task_interaction_requests_terminal_reason",
    )


# --------------------------------------------------------------------------
# T-ck-7..10: slot admission CHECKs
# --------------------------------------------------------------------------


def test_active_slot_value_rejects_other_than_one(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    row = make_row(task_id=task_id, resume_trace_event_id=anchor_id, active_slot=2)
    assert_rejected(db_session, row, "ck_task_interaction_requests_active_slot_value")


def test_active_status_and_slot_are_paired_both_ways(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(task_id=task_id, resume_trace_event_id=anchor_id, active_slot=None),
        "ck_task_interaction_requests_active_slot_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            active_slot=1,
        ),
        "ck_task_interaction_requests_active_slot_pairs_status",
    )


def test_active_row_requires_anchor(db_session, fixtures) -> None:
    """Also what turns the anchor FK's ON DELETE SET NULL into an effective
    RESTRICT for active rows -- see T-fk-1 below and the SQLite half.
    """
    task_id, _anchor_id = fixtures
    row = make_row(task_id=task_id, resume_trace_event_id=None)
    assert_rejected(db_session, row, "ck_task_interaction_requests_active_anchor")


def test_active_row_requires_protocol_version_one(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(task_id=task_id, resume_trace_event_id=anchor_id, protocol_version=2),
        "ck_task_interaction_requests_active_protocol",
    )
    assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            protocol_version=2,
        ),
    )


def test_protocol_version_floor_rejects_nonsense_on_terminal_rows(
    db_session, fixtures
) -> None:
    """Rejects values that are not version numbers at all (-1, 0) on every
    row, including the positive control that a future version is accepted
    on a terminal row by design -- see the SQLite half."""
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            protocol_version=-1,
        ),
        "ck_task_interaction_requests_protocol_version_floor",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            protocol_version=0,
        ),
        "ck_task_interaction_requests_protocol_version_floor",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            protocol_version=-1,
        ),
        "ck_task_interaction_requests_protocol_version_floor",
    )
    assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            protocol_version=2,
        ),
    )


# --------------------------------------------------------------------------
# T-ck-11..17: paired CHECKs, plus the full-pairing positive control
# --------------------------------------------------------------------------


def test_terminated_status_and_terminal_reason_are_paired_both_ways(
    db_session, fixtures
) -> None:
    """status='terminated' iff terminal_reason IS NOT NULL. The answered
    case is the one worth pinning -- see the SQLite half."""
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            terminal_reason=None,
        ),
        "ck_task_interaction_requests_terminal_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            terminal_reason="deadline_elapsed",
        ),
        "ck_task_interaction_requests_terminal_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            terminal_reason="deadline_elapsed",
        ),
        "ck_task_interaction_requests_terminal_pairs_status",
    )


def test_terminated_status_and_terminated_at_are_paired_both_ways(
    db_session, fixtures
) -> None:
    """status='terminated' iff terminated_at IS NOT NULL -- see the SQLite half."""
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            terminated_at=None,
        ),
        "ck_task_interaction_requests_terminated_at_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            terminated_at=datetime.now(timezone.utc),
        ),
        "ck_task_interaction_requests_terminated_at_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            terminated_at=datetime.now(timezone.utc),
        ),
        "ck_task_interaction_requests_terminated_at_pairs_status",
    )


def test_answered_status_and_response_payload_are_paired_both_ways(
    db_session, fixtures
) -> None:
    """status='answered' iff response_payload IS NOT NULL -- see the SQLite
    half."""
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            response_payload=None,
        ),
        "ck_task_interaction_requests_response_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            response_payload={"stray": "value"},
        ),
        "ck_task_interaction_requests_response_pairs_status",
    )


def test_answered_status_and_responded_at_are_paired_both_ways(
    db_session, fixtures
) -> None:
    """status='answered' iff responded_at IS NOT NULL -- see the SQLite
    half."""
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            responded_at=None,
            responder_identity=None,
        ),
        "ck_task_interaction_requests_responded_at_pairs_status",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            responded_at=datetime.now(timezone.utc),
            responder_identity="user:1",
        ),
        "ck_task_interaction_requests_responded_at_pairs_status",
    )


def test_responder_identity_pairs_responded_at_both_ways(db_session, fixtures) -> None:
    """Renamed from ck_task_interaction_requests_responder_identity_pairs_
    responded_at (66 chars, over PostgreSQL's own 63-char identifier limit)
    -- see the SQLite half and
    test_no_constraint_name_exceeds_the_postgres_identifier_limit there.
    """
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            responder_identity=None,
        ),
        "ck_task_interaction_requests_responder_pairs_responded_at",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            responder_identity="user:1",
        ),
        "ck_task_interaction_requests_responder_pairs_responded_at",
    )


def test_expiry_must_be_after_creation(db_session, fixtures) -> None:
    """created_at and expires_at are both bound explicitly here so the
    equal/before cases do not race the server clock -- see the SQLite half
    for why."""
    task_id, anchor_id = fixtures
    fixed = datetime(2026, 1, 1, tzinfo=timezone.utc)
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            created_at=fixed,
            expires_at=fixed,
        ),
        "ck_task_interaction_requests_expiry_after_creation",
    )
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            created_at=fixed,
            expires_at=fixed - timedelta(minutes=1),
        ),
        "ck_task_interaction_requests_expiry_after_creation",
    )


def test_answered_row_with_full_pairing_is_accepted(db_session, fixtures) -> None:
    """Positive control -- see the SQLite half."""
    task_id, anchor_id = fixtures
    row = make_row(task_id=task_id, resume_trace_event_id=anchor_id, status="answered")
    assert_accepted(db_session, row)


# --------------------------------------------------------------------------
# T-empty: empty-string CHECKs
# --------------------------------------------------------------------------


@pytest.mark.parametrize(
    "column",
    [
        "run_id",
        "resume_event_id",
        "resume_execution_id",
        "resume_run_partition",
        "request_idempotency_key",
    ],
)
def test_empty_string_is_rejected(db_session, fixtures, column) -> None:
    """NOT NULL alone does not stop a caller writing "" -- see the SQLite
    half."""
    task_id, anchor_id = fixtures
    row = make_row(task_id=task_id, resume_trace_event_id=anchor_id, **{column: ""})
    assert_rejected(db_session, row, f"ck_task_interaction_requests_{column}_nonempty")


def test_responder_identity_rejects_empty_string(db_session, fixtures) -> None:
    """'' satisfies the responder pairing CHECK but names no responder --
    see the SQLite half."""
    task_id, anchor_id = fixtures
    assert_rejected(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            responder_identity="",
        ),
        "ck_task_interaction_requests_responder_identity_nonempty",
    )


def test_run_id_may_differ_from_resume_run_partition(db_session, fixtures) -> None:
    """Negative control for the deleted CHECK -- see the SQLite half."""
    task_id, anchor_id = fixtures
    row = make_row(
        task_id=task_id,
        resume_trace_event_id=anchor_id,
        run_id="run-one-value",
        resume_run_partition="a-different-partition-value",
    )
    assert_accepted(db_session, row)


# --------------------------------------------------------------------------
# T-fk: foreign-key delete matrix
# --------------------------------------------------------------------------


def test_deleting_anchor_of_active_row_is_blocked(db_session, fixtures) -> None:
    """resume_trace_event_id is ON DELETE SET NULL, but
    ck_task_interaction_requests_active_anchor requires a non-null anchor on
    an active row -- the delete's SET NULL fails that CHECK instead of
    going through -- see the SQLite half.
    """
    task_id, anchor_id = fixtures
    assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )

    anchor = db_session.get(TraceEvent, anchor_id)
    db_session.delete(anchor)
    try:
        db_session.commit()
    except IntegrityError as exc:
        assert "ck_task_interaction_requests_active_anchor" in str(exc), (
            f"expected the active-anchor CHECK name in the error, got: {exc}"
        )
    else:
        raise AssertionError("deleting an active row's anchor must be blocked")
    finally:
        db_session.rollback()


def test_deleting_anchor_of_terminal_row_sets_null(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    row = assert_accepted(
        db_session,
        make_row(task_id=task_id, resume_trace_event_id=anchor_id, status="terminated"),
    )
    row_id = row.id

    anchor = db_session.get(TraceEvent, anchor_id)
    db_session.delete(anchor)
    db_session.commit()

    reloaded = db_session.get(TaskInteractionRequest, row_id)
    assert reloaded.resume_trace_event_id is None


def test_deleting_unrelated_trace_event_is_unaffected(db_session, fixtures) -> None:
    task_id, anchor_id = fixtures
    row = assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    row_id = row.id
    other_event_id = make_trace_event(db_session, task_id=task_id)

    other_event = db_session.get(TraceEvent, other_event_id)
    db_session.delete(other_event)
    db_session.commit()

    reloaded = db_session.get(TaskInteractionRequest, row_id)
    assert reloaded.resume_trace_event_id == anchor_id


def test_deleting_task_cascades_interaction_rows(db_session) -> None:
    """Uses a dedicated task with no trace_events pointing at it -- see the
    SQLite half for why."""
    user_id = make_user(db_session)
    task_id = make_task(db_session, user_id=user_id)
    assert_accepted(
        db_session,
        make_row(task_id=task_id, resume_trace_event_id=None, status="terminated"),
    )

    task = db_session.get(Task, task_id)
    db_session.delete(task)
    db_session.commit()

    remaining = (
        db_session.query(TaskInteractionRequest)
        .filter(TaskInteractionRequest.task_id == task_id)
        .count()
    )
    assert remaining == 0


def test_deleting_responder_user_sets_null_and_keeps_identity(
    db_session, fixtures
) -> None:
    """responder_identity and responded_at are untouched by the SET NULL --
    see the SQLite half and the model's class docstring."""
    task_id, anchor_id = fixtures
    responder_id = make_user(db_session)
    row = assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            responder_user_id=responder_id,
            responder_identity="user:responder",
        ),
    )
    row_id = row.id
    original_responded_at = row.responded_at

    responder = db_session.get(User, responder_id)
    db_session.delete(responder)
    db_session.commit()

    reloaded = db_session.get(TaskInteractionRequest, row_id)
    assert reloaded.responder_user_id is None
    assert reloaded.responder_identity == "user:responder"
    assert reloaded.responded_at == original_responded_at


# --------------------------------------------------------------------------
# T-store: storage-form sentinels
# --------------------------------------------------------------------------


def test_response_payload_none_lands_as_sql_null(db_session, fixtures) -> None:
    """JSON(none_as_null=True): a Python None payload lands as SQL NULL,
    while a JSON null nested inside a payload does not -- see the SQLite
    half."""
    task_id, anchor_id = fixtures
    none_row = assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    is_null = db_session.execute(
        text(
            "SELECT response_payload IS NULL FROM task_interaction_requests WHERE id = :id"
        ),
        {"id": none_row.id},
    ).scalar_one()
    assert bool(is_null) is True

    nested_null_row = assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="answered",
            response_payload={"answer": None},
        ),
    )
    is_null_nested = db_session.execute(
        text(
            "SELECT response_payload IS NULL FROM task_interaction_requests WHERE id = :id"
        ),
        {"id": nested_null_row.id},
    ).scalar_one()
    assert bool(is_null_nested) is False
    assert nested_null_row.response_payload == {"answer": None}


def test_request_payload_none_is_rejected(db_session, fixtures) -> None:
    """request_payload is NOT NULL, and JSON(none_as_null=True) is what
    makes that constraint actually fire on a Python None -- see the SQLite
    half and the model's class docstring. Not routed through
    assert_rejected: this is a column NOT NULL violation, not a named
    CHECK, so there is no constraint name for that helper to match against.
    """
    task_id, anchor_id = fixtures
    row = make_row(
        task_id=task_id, resume_trace_event_id=anchor_id, request_payload=None
    )
    obj = TaskInteractionRequest(**row)
    db_session.add(obj)
    with pytest.raises(IntegrityError, match="violates not-null constraint"):
        db_session.commit()
    db_session.rollback()


def test_expires_at_round_trips_as_utc(db_session, fixtures) -> None:
    """PostgreSQL normalizes a non-UTC-but-aware value to the correct UTC
    instant instead of storing it verbatim (contrast the SQLite half, where
    the same input is stored as wrong-instant local wall-clock time)."""
    task_id, anchor_id = fixtures
    fixed_created_at = datetime(2026, 1, 1, tzinfo=timezone.utc)
    utc_value = datetime(2026, 6, 1, 12, 0, 0, tzinfo=timezone.utc)
    utc_row = assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            created_at=fixed_created_at,
            expires_at=utc_value,
        ),
    )
    assert utc_row.expires_at == utc_value

    plus_eight_value = datetime(
        2026, 6, 1, 20, 0, 0, tzinfo=timezone(timedelta(hours=8))
    )
    non_utc_row = assert_accepted(
        db_session,
        make_row(
            task_id=task_id,
            resume_trace_event_id=anchor_id,
            status="terminated",
            created_at=fixed_created_at,
            expires_at=plus_eight_value,
        ),
    )
    # The +08:00 instant and utc_value are the same wall-clock moment
    # (12:00 UTC); PostgreSQL normalizes on write, so this must round-trip
    # to that shared instant rather than to 20:00. The SQLite twin (same
    # test name) asserts the opposite outcome -- it reads back the bare
    # "20:00:00" local digits; the divergence is measured backend behavior,
    # not an inconsistency between the two suites.
    assert non_utc_row.expires_at == utc_value


# --------------------------------------------------------------------------
# T-update: the paired CHECKs against an UPDATE, not just an INSERT
# --------------------------------------------------------------------------


def test_answered_transition_in_one_statement_is_accepted(db_session, fixtures) -> None:
    """Positive control for the UPDATE-path tests below -- see the SQLite
    half."""
    task_id, anchor_id = fixtures
    row = assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    updated = assert_update_accepted(
        db_session,
        row.id,
        {
            "status": "answered",
            "active_slot": None,
            "response_payload": {"answer": "example"},
            "responded_at": datetime.now(timezone.utc),
            "responder_identity": "user:1",
        },
    )
    assert updated.status == "answered"


def test_answering_without_clearing_the_slot_is_rejected(db_session, fixtures) -> None:
    """Answering a row while forgetting to clear active_slot -- see the
    SQLite half."""
    task_id, anchor_id = fixtures
    row = assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    assert_update_rejected(
        db_session,
        row.id,
        {
            "status": "answered",
            "response_payload": {"answer": "example"},
            "responded_at": datetime.now(timezone.utc),
            "responder_identity": "user:1",
        },
        "ck_task_interaction_requests_active_slot_pairs_status",
    )


def test_clearing_the_slot_without_leaving_active_is_rejected(
    db_session, fixtures
) -> None:
    """The other direction of the same CHECK -- see the SQLite half."""
    task_id, anchor_id = fixtures
    row = assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    assert_update_rejected(
        db_session,
        row.id,
        {"active_slot": None},
        "ck_task_interaction_requests_active_slot_pairs_status",
    )


def test_terminating_without_a_timestamp_is_rejected(db_session, fixtures) -> None:
    """Terminating a row while leaving terminated_at NULL -- see the
    SQLite half."""
    task_id, anchor_id = fixtures
    row = assert_accepted(
        db_session, make_row(task_id=task_id, resume_trace_event_id=anchor_id)
    )
    assert_update_rejected(
        db_session,
        row.id,
        {
            "status": "terminated",
            "active_slot": None,
            "terminal_reason": "deadline_elapsed",
        },
        "ck_task_interaction_requests_terminated_at_pairs_status",
    )


# --------------------------------------------------------------------------
# T-shape: create_all shape
# --------------------------------------------------------------------------


def test_created_columns_match_the_frozen_shape(db_session) -> None:
    inspector = inspect(get_engine())
    columns = {c["name"]: c for c in inspector.get_columns("task_interaction_requests")}
    assert set(columns) == EXPECTED_COLUMNS
    # Closes EXPECTED_NULLABLE the same way EXPECTED_STRING_LENGTHS is closed
    # below -- see the SQLite half.
    assert set(EXPECTED_NULLABLE) == set(columns)
    for name, expected_nullable in EXPECTED_NULLABLE.items():
        assert columns[name]["nullable"] == expected_nullable, name
    string_columns = {
        name
        for name, column in columns.items()
        if getattr(column["type"], "length", None) is not None
    }
    assert set(EXPECTED_STRING_LENGTHS) == string_columns
    for name, expected_length in EXPECTED_STRING_LENGTHS.items():
        assert columns[name]["type"].length == expected_length, name


def test_all_timestamp_columns_are_timezone_aware(db_session) -> None:
    """Unlike the SQLite half, PostgreSQL's reflection actually reports
    this: str(column["type"]) prints "TIMESTAMP" either way, but
    column["type"].timezone distinguishes timestamp with time zone from
    timestamp without time zone (verified against information_schema).

    The set comparison closes the inventory the same way the SQLite half's
    declared-column version does: TIMESTAMP_COLUMNS must name exactly the
    reflected DateTime-typed columns, not merely a subset of them.
    """
    inspector = inspect(get_engine())
    columns = {c["name"]: c for c in inspector.get_columns("task_interaction_requests")}
    reflected_datetime_columns = {
        name for name, column in columns.items() if isinstance(column["type"], DateTime)
    }
    assert reflected_datetime_columns == set(TIMESTAMP_COLUMNS)
    for name in TIMESTAMP_COLUMNS:
        assert columns[name]["type"].timezone is True, name


def test_constraint_names_match_the_frozen_inventory(db_session) -> None:
    inspector = inspect(get_engine())

    unique = {
        uc["name"]: tuple(sorted(uc["column_names"]))
        for uc in inspector.get_unique_constraints("task_interaction_requests")
    }
    assert unique == EXPECTED_UNIQUE_CONSTRAINTS

    checks = {
        c["name"] for c in inspector.get_check_constraints("task_interaction_requests")
    }
    assert checks == EXPECTED_CHECK_CONSTRAINT_NAMES

    fks = {
        fk["name"]: (
            fk["referred_table"],
            tuple(fk["referred_columns"]),
            (fk["options"] or {}).get("ondelete"),
        )
        for fk in inspector.get_foreign_keys("task_interaction_requests")
    }
    assert fks == EXPECTED_FOREIGN_KEYS

    # PostgreSQL also reports the two UNIQUE constraints' backing indexes
    # here (unique=True); filtering to unique=False first is what makes
    # this literal apply to both backends -- see EXPECTED_NONUNIQUE_INDEXES.
    nonunique_indexes = {
        idx["name"]: tuple(sorted(idx["column_names"]))
        for idx in inspector.get_indexes("task_interaction_requests")
        if not idx["unique"]
    }
    assert nonunique_indexes == EXPECTED_NONUNIQUE_INDEXES