@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_phase170_doctor_schema.py

@@ -1,319 +0,0 @@
-"""Tests for Phase 170 P170-D: doctor schema command and repair-dispatch pre-check.
-
-Covers TSK-170.11 (operator schema inspection surface), TSK-170.12 (remediation guidance),
-and TSK-170.13 (repair-dispatch schema pre-check). All tests mock PostgresStateStore and
-_resolve_state_dsn so no live database is required.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-from unittest.mock import MagicMock, patch
-
-# Importing doctor_cmds registers all @doctor_app.command() decorators.
-import vds_audit_orchestrator.doctor_cmds
-from typer.testing import CliRunner
-from vds_audit_orchestrator.cli_common import doctor_app
-from vds_audit_orchestrator.state.store import (
-    SchemaCompatibilityResult,
-    SchemaContractViolation,
-    SchemaIncompatibilityKind,
-)
-
-runner = CliRunner()
-
-_FAKE_DSN = "postgresql://test:test@localhost/test"
-
-
-def _make_compat_result(
-    status: str,
-    violations: list[SchemaContractViolation] | None = None,
-) -> SchemaCompatibilityResult:
-    r = SchemaCompatibilityResult(status=status)
-    r.violations = violations or []
-    return r
-
-
-def _make_mock_store(compat_result: SchemaCompatibilityResult) -> MagicMock:
-    """Return a MagicMock that behaves like PostgresStateStore."""
-    store = MagicMock()
-    store._schema_compat_result = compat_result
-    return store
-
-
-def _missing_table_violation(table: str) -> SchemaContractViolation:
-    return SchemaContractViolation(
-        kind=SchemaIncompatibilityKind.SCHEMA_MISSING_TABLE,
-        table_name=table,
-        column_name=None,
-        repair_eligible=False,
-        repair_attempted=False,
-        repair_succeeded=None,
-        is_blocking=True,
-        detail=f"audit_state.{table} is missing",
-    )
-
-
-def _missing_column_violation(table: str, col: str, *, repaired: bool = False) -> SchemaContractViolation:
-    return SchemaContractViolation(
-        kind=SchemaIncompatibilityKind.SCHEMA_MISSING_COLUMN
-        if not repaired
-        else SchemaIncompatibilityKind.SCHEMA_MISSING_COLUMN,
-        table_name=table,
-        column_name=col,
-        repair_eligible=True,
-        repair_attempted=True,
-        repair_succeeded=repaired or None,
-        is_blocking=not repaired,
-        detail=f"Column {col} missing from {table}",
-    )
-
-
-# ---------------------------------------------------------------------------
-# TSK-170.11 + TSK-170.12: doctor schema command output
-# ---------------------------------------------------------------------------
-
-
-class TestDoctorSchemaCommand:
-    """TSK-170.11/12 — doctor schema CLI: exit codes, JSON, remediation."""
-
-    def _invoke(self, args: list[str], compat_result: SchemaCompatibilityResult) -> Any:
-        mock_store = _make_mock_store(compat_result)
-        with (
-            patch("vds_audit_orchestrator.doctor_cmds._resolve_state_dsn", return_value=_FAKE_DSN),
-            patch("vds_audit_orchestrator.doctor_cmds.PostgresStateStore", return_value=mock_store),
-        ):
-            return runner.invoke(doctor_app, args)
-
-    def test_compliant_exits_0(self) -> None:
-        """Exit code 0 when schema is fully compliant."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("compliant"))
-        assert result.exit_code == 0
-
-    def test_repaired_now_exits_0(self) -> None:
-        """Exit code 0 when schema was auto-repaired (dispatch still safe)."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("repaired_now"))
-        assert result.exit_code == 0
-
-    def test_incompatible_blocking_exits_2(self) -> None:
-        """Exit code 2 for incompatible_blocking status."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs")],
-        )
-        result = self._invoke(["schema", "--json"], compat)
-        assert result.exit_code == 2
-
-    def test_unreachable_exits_1(self) -> None:
-        """Exit code 1 for unreachable status."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("unreachable"))
-        assert result.exit_code == 1
-
-    # ── JSON output structure (TSK-170.11) ───────────────────────────────────
-
-    def test_json_includes_status(self) -> None:
-        """JSON output must include status field."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("compliant"))
-        payload = json.loads(result.output)
-        assert payload["status"] == "compliant"
-
-    def test_json_includes_dispatch_safe_true_for_compliant(self) -> None:
-        """dispatch_safe must be True for compliant status."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("compliant"))
-        payload = json.loads(result.output)
-        assert payload["dispatch_safe"] is True
-
-    def test_json_includes_dispatch_safe_false_for_incompatible(self) -> None:
-        """dispatch_safe must be False for incompatible_blocking status."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs")],
-        )
-        result = self._invoke(["schema", "--json"], compat)
-        payload = json.loads(result.output)
-        assert payload["dispatch_safe"] is False
-
-    def test_json_includes_missing_tables(self) -> None:
-        """JSON output must list missing tables."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs"), _missing_table_violation("dispatch_lanes")],
-        )
-        result = self._invoke(["schema", "--json"], compat)
-        payload = json.loads(result.output)
-        assert "dispatch_runs" in payload["missing_tables"]
-        assert "dispatch_lanes" in payload["missing_tables"]
-
-    def test_json_includes_violations_list(self) -> None:
-        """JSON output must include violations with kind, table_name, is_blocking."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_events")],
-        )
-        result = self._invoke(["schema", "--json"], compat)
-        payload = json.loads(result.output)
-        assert len(payload["violations"]) == 1
-        v = payload["violations"][0]
-        assert v["table_name"] == "dispatch_events"
-        assert v["is_blocking"] is True
-        assert "kind" in v
-
-    def test_json_includes_repaired_items_when_repaired(self) -> None:
-        """JSON output must include repaired_items when repair succeeded."""
-        repaired_violation = SchemaContractViolation(
-            kind=SchemaIncompatibilityKind.SCHEMA_MISSING_COLUMN,
-            table_name="dispatch_lanes",
-            column_name="claimed_at",
-            repair_eligible=True,
-            repair_attempted=True,
-            repair_succeeded=True,
-            is_blocking=False,
-            detail="claimed_at column was missing",
-        )
-        compat = _make_compat_result("repaired_now", [repaired_violation])
-        result = self._invoke(["schema", "--json"], compat)
-        payload = json.loads(result.output)
-        assert len(payload["repaired_items"]) == 1
-        assert "dispatch_lanes" in payload["repaired_items"][0]
-        assert "claimed_at" in payload["repaired_items"][0]
-
-    # ── TSK-170.12: Remediation guidance ─────────────────────────────────────
-
-    def test_json_includes_remediation_for_compliant(self) -> None:
-        """Remediation must mention 'safe' for compliant status."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("compliant"))
-        payload = json.loads(result.output)
-        assert "safe" in payload["remediation"].lower()
-
-    def test_json_includes_remediation_for_incompatible(self) -> None:
-        """Remediation must mention 'init' or 'migration' for blocking status."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs")],
-        )
-        result = self._invoke(["schema", "--json"], compat)
-        payload = json.loads(result.output)
-        remediation = payload["remediation"].lower()
-        assert "state init" in remediation or "migration" in remediation or "incompatible" in remediation
-
-    def test_json_includes_remediation_for_repaired_now(self) -> None:
-        """Remediation must mention 'repaired' or 'safe' for repaired_now."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("repaired_now"))
-        payload = json.loads(result.output)
-        remediation = payload["remediation"].lower()
-        assert "repaired" in remediation or "safe" in remediation
-
-    def test_json_operation_field_is_doctor_schema(self) -> None:
-        """JSON output operation field must be 'doctor_schema'."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("compliant"))
-        payload = json.loads(result.output)
-        assert payload["operation"] == "doctor_schema"
-
-    def test_json_db_reachable_false_for_unreachable(self) -> None:
-        """db_reachable must be False for unreachable status."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("unreachable"))
-        payload = json.loads(result.output)
-        assert payload["db_reachable"] is False
-
-    def test_json_db_reachable_true_for_compliant(self) -> None:
-        """db_reachable must be True for compliant status."""
-        result = self._invoke(["schema", "--json"], _make_compat_result("compliant"))
-        payload = json.loads(result.output)
-        assert payload["db_reachable"] is True
-
-    def test_connection_failure_exits_1(self) -> None:
-        """If PostgresStateStore() raises, exit code must be 1."""
-        with (
-            patch("vds_audit_orchestrator.doctor_cmds._resolve_state_dsn", return_value=_FAKE_DSN),
-            patch(
-                "vds_audit_orchestrator.doctor_cmds.PostgresStateStore",
-                side_effect=Exception("connection refused"),
-            ),
-        ):
-            result = runner.invoke(doctor_app, ["schema", "--json"])
-        assert result.exit_code == 1
-
-
-# ---------------------------------------------------------------------------
-# TSK-170.13: doctor repair-dispatch schema pre-check
-# ---------------------------------------------------------------------------
-
-
-class TestDoctorRepairDispatchSchemaPrecheck:
-    """TSK-170.13 — repair-dispatch must detect incompatible schema before repair."""
-
-    def _invoke_repair_dispatch(
-        self, compat_result: SchemaCompatibilityResult, extra_args: list[str] | None = None
-    ) -> Any:
-        mock_store = _make_mock_store(compat_result)
-        with (
-            patch("vds_audit_orchestrator.doctor_cmds._resolve_state_dsn", return_value=_FAKE_DSN),
-            patch("vds_audit_orchestrator.doctor_cmds.PostgresStateStore", return_value=mock_store),
-        ):
-            return runner.invoke(
-                doctor_app,
-                ["repair-dispatch", "--json", "--force"] + (extra_args or []),
-            )
-
-    def test_repair_blocked_when_schema_incompatible_blocking(self) -> None:
-        """repair-dispatch must exit before repair when schema is incompatible_blocking."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs")],
-        )
-        result = self._invoke_repair_dispatch(compat)
-        assert result.exit_code == 2
-
-    def test_repair_blocked_when_schema_unreachable(self) -> None:
-        """repair-dispatch must exit before repair when DB is unreachable."""
-        result = self._invoke_repair_dispatch(_make_compat_result("unreachable"))
-        assert result.exit_code == 2
-
-    def test_repair_json_includes_schema_compatibility_reason(self) -> None:
-        """repair-dispatch JSON output must include schema_compatibility field on block."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs")],
-        )
-        result = self._invoke_repair_dispatch(compat)
-        payload = json.loads(result.output)
-        assert "schema_compatibility" in payload
-        assert payload["schema_compatibility"]["status"] == "incompatible_blocking"
-
-    def test_repair_schema_compatibility_includes_blocking_reasons(self) -> None:
-        """repair-dispatch JSON must list blocking_reasons under schema_compatibility."""
-        compat = _make_compat_result(
-            "incompatible_blocking",
-            [_missing_table_violation("dispatch_runs"), _missing_table_violation("dispatch_lanes")],
-        )
-        result = self._invoke_repair_dispatch(compat)
-        payload = json.loads(result.output)
-        reasons = payload["schema_compatibility"]["blocking_reasons"]
-        assert any("dispatch_runs" in r for r in reasons)
-
-    def test_repair_proceeds_when_schema_compliant(self) -> None:
-        """repair-dispatch must NOT be blocked when schema is compliant."""
-        mock_store = _make_mock_store(_make_compat_result("compliant"))
-        # list_active_dispatch_runs returns empty list → "no stuck runs" path
-        mock_store.list_active_dispatch_runs.return_value = []
-        with (
-            patch("vds_audit_orchestrator.doctor_cmds._resolve_state_dsn", return_value=_FAKE_DSN),
-            patch("vds_audit_orchestrator.doctor_cmds.PostgresStateStore", return_value=mock_store),
-        ):
-            result = runner.invoke(doctor_app, ["repair-dispatch", "--json", "--force"])
-        # exit 0 (no stuck runs found is ok)
-        assert result.exit_code == 0
-        payload = json.loads(result.output)
-        assert "schema_compatibility" not in payload  # no block message
-
-    def test_repair_proceeds_when_schema_repaired_now(self) -> None:
-        """repair-dispatch must NOT be blocked when schema status is repaired_now."""
-        mock_store = _make_mock_store(_make_compat_result("repaired_now"))
-        mock_store.list_active_dispatch_runs.return_value = []
-        with (
-            patch("vds_audit_orchestrator.doctor_cmds._resolve_state_dsn", return_value=_FAKE_DSN),
-            patch("vds_audit_orchestrator.doctor_cmds.PostgresStateStore", return_value=mock_store),
-        ):
-            result = runner.invoke(doctor_app, ["repair-dispatch", "--json", "--force"])
-        assert result.exit_code == 0

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_phase170_regression.py

@@ -1,334 +0,0 @@
-"""Phase 170 regression and idempotency tests.
-
-TSK-170.14: Idempotency — repeated repair attempts must not error; IF NOT EXISTS
-makes the repair SQL safe to run against a schema that already has claimed_at.
-
-TSK-170.15: Live incident regression.  The incident shape is:
-
-    audit_state.dispatch_lanes  EXISTS
-    dispatch_lanes.claimed_at   MISSING
-    Phase 168 dispatch startup  ATTEMPTED
-
-The old (unsafe) path:
-  - Store initialised without detecting missing claimed_at
-  - dispatch_state_persist_failed logged on INSERT (claimed_at NULL violation)
-  - _dispatch_store silently set to None
-  - Dispatch continued under "assumed DB-native" fallback — unsafe
-
-The new (safe) path:
-  - _ensure_runtime_schema_compatibility() runs during PostgresStateStore.__init__
-  - Missing claimed_at detected; safe additive repair is attempted immediately
-  - Repair success  → status=repaired_now  → dispatch_schema_gate() warns but PASSES
-  - Repair failure  → status=incompatible_blocking → dispatch_schema_gate() RAISES
-  - DispatchSchemaIncompatibleError propagates before any dispatch state is created
-
-All tests mock psycopg.connect; no live database is required.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-from unittest.mock import MagicMock, patch
-
-import pytest
-from vds_audit_orchestrator.state.store import (
-    _DISPATCH_SCHEMA_CONTRACT,  # TSK-170.14: verify repair SQL
-    DispatchSchemaIncompatibleError,  # TSK-170.15: gate sentinel
-    PostgresStateStore,
-    SchemaIncompatibilityKind,
-    dispatch_schema_gate,  # TSK-170.15: gate under test
-)
-
-# ---------------------------------------------------------------------------
-# Shared helpers — mirrors test_schema_contract_phase170.py helpers
-# ---------------------------------------------------------------------------
-
-_ALL_DISPATCH_TABLES = [
-    "dispatch_runs",
-    "dispatch_lanes",
-    "dispatch_lane_attempts",
-    "dispatch_events",
-    "availability_snapshots",
-    "dispatch_lane_contracts",
-    "dispatch_lane_output_envelopes",
-]
-
-
-def _make_store_with_mock(
-    fetchall_tables: list[str],
-    fetchall_columns: list[tuple[str, str]],
-    repair_side_effect: Any = None,
-) -> tuple[PostgresStateStore, MagicMock]:
-    """Build a PostgresStateStore with a mock connection; return (store, cursor_mock).
-
-    ``repair_side_effect``: if set, raised when the repair ALTER TABLE SQL is executed.
-    """
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-
-        tables_rows = [{"table_name": t} for t in fetchall_tables]
-        columns_rows = [{"table_name": t, "column_name": c} for t, c in fetchall_columns]
-
-        cur.fetchall.side_effect = [tables_rows, columns_rows]
-
-        if repair_side_effect is not None:
-
-            def _execute(sql: str, *_args: object, **_kwargs: object) -> None:
-                if "ADD COLUMN IF NOT EXISTS claimed_at" in sql:
-                    raise repair_side_effect  # type: ignore[misc]
-
-            cur.execute.side_effect = _execute
-
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.return_value = MagicMock()
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test:test@localhost/test")
-        cur.fetchall.side_effect = None
-        cur.fetchall.return_value = []
-        return store, cur
-
-
-# ---------------------------------------------------------------------------
-# TSK-170.14: Idempotency
-# ---------------------------------------------------------------------------
-
-
-class TestP170ERepairIdempotency:
-    """TSK-170.14 — Repair attempts must be idempotent; no error on repeated runs."""
-
-    def test_repair_sql_contains_if_not_exists(self) -> None:
-        """The claimed_at repair SQL must use IF NOT EXISTS — structural idempotency guarantee."""
-        claimed_at_item = next(
-            item
-            for item in _DISPATCH_SCHEMA_CONTRACT
-            if item.table_name == "dispatch_lanes" and item.column_name == "claimed_at"
-        )
-        assert claimed_at_item.repair_sql is not None, "claimed_at contract item must have repair_sql"
-        assert "IF NOT EXISTS" in claimed_at_item.repair_sql, (
-            "Repair SQL must include IF NOT EXISTS so running it twice is safe"
-        )
-
-    def test_repair_sql_targets_correct_table_and_column(self) -> None:
-        """Repair SQL must reference dispatch_lanes and claimed_at explicitly."""
-        claimed_at_item = next(
-            item
-            for item in _DISPATCH_SCHEMA_CONTRACT
-            if item.table_name == "dispatch_lanes" and item.column_name == "claimed_at"
-        )
-        sql = claimed_at_item.repair_sql or ""
-        assert "dispatch_lanes" in sql
-        assert "claimed_at" in sql
-
-    def test_repair_sql_adds_timestamptz_column(self) -> None:
-        """Repair SQL must add a TIMESTAMPTZ column — not a weaker or different type."""
-        claimed_at_item = next(
-            item
-            for item in _DISPATCH_SCHEMA_CONTRACT
-            if item.table_name == "dispatch_lanes" and item.column_name == "claimed_at"
-        )
-        sql = (claimed_at_item.repair_sql or "").upper()
-        assert "TIMESTAMPTZ" in sql or "TIMESTAMP WITH TIME ZONE" in sql, "claimed_at must be a TIMESTAMPTZ column"
-
-    def test_second_startup_after_repair_is_compliant(self) -> None:
-        """After a successful repair, a second store init (claimed_at now present) is compliant."""
-        # Simulate the state AFTER a successful repair: claimed_at now exists in the schema
-        # Include Phase 169 columns (heartbeat_at, event_type) as well since they
-        # are also part of the schema contract and would trigger repaired_now if missing
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[
-                ("dispatch_lanes", "claimed_at"),  # Phase 170 column
-                ("dispatch_runs", "heartbeat_at"),  # Phase 169 column
-                ("dispatch_events", "event_type"),  # Phase 169 column
-            ],
-        )
-        result = store._schema_compat_result
-        assert result.status == "compliant", (
-            "Second startup with claimed_at present must be compliant, not repaired_now"
-        )
-        assert result.violations == [], "No violations expected when schema is fully compliant"
-
-    def test_second_startup_after_repair_has_no_repair_violations(self) -> None:
-        """After repair, a second startup must not produce SCHEMA_REPAIR_FAILED violations."""
-        # Include Phase 169 columns (heartbeat_at, event_type) as well
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[
-                ("dispatch_lanes", "claimed_at"),  # Phase 170 column
-                ("dispatch_runs", "heartbeat_at"),  # Phase 169 column
-                ("dispatch_events", "event_type"),  # Phase 169 column
-            ],
-        )
-        repair_violations = [
-            v
-            for v in store._schema_compat_result.violations
-            if v.kind == SchemaIncompatibilityKind.SCHEMA_REPAIR_FAILED
-        ]
-        assert repair_violations == [], "No repair-failed violations on a schema that is already healthy"
-
-    def test_repair_attempted_exactly_once_per_startup(self) -> None:
-        """Each startup cycle attempts the repair ALTER TABLE at most once per missing column."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            conn = MagicMock()
-            cur = MagicMock()
-
-            tables_rows = [{"table_name": t} for t in _ALL_DISPATCH_TABLES]
-            columns_rows: list[dict[str, str]] = []  # claimed_at missing → triggers repair
-
-            cur.fetchall.side_effect = [tables_rows, columns_rows]
-            conn.cursor.return_value.__enter__.return_value = cur
-            conn.transaction.return_value = MagicMock()
-            mock_connect.return_value = conn
-
-            PostgresStateStore("postgresql://test:test@localhost/test")
-
-        alter_calls = [
-            c for c in cur.execute.call_args_list if c.args and "ADD COLUMN IF NOT EXISTS claimed_at" in str(c.args[0])
-        ]
-        assert len(alter_calls) == 1, f"Expected exactly 1 repair ALTER TABLE call, got {len(alter_calls)}"
-
-
-# ---------------------------------------------------------------------------
-# TSK-170.15: Live incident regression
-# ---------------------------------------------------------------------------
-
-
-class TestP170ELiveIncidentRegression:
-    """TSK-170.15 — Reproduces the exact live incident drift shape.
-
-    Incident: dispatch_lanes exists, claimed_at is missing,
-    Phase 168 dispatch startup attempted.
-
-    Guards against regression to the old unsafe continuation path.
-    """
-
-    def test_incident_shape_detected_during_store_init(self) -> None:
-        """Missing claimed_at is detected as a violation during PostgresStateStore.__init__."""
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],  # claimed_at absent — exact incident shape
-        )
-        claimed_at_violations = [
-            v
-            for v in store._schema_compat_result.violations
-            if v.table_name == "dispatch_lanes" and v.column_name == "claimed_at"
-        ]
-        assert len(claimed_at_violations) >= 1, (
-            "Missing claimed_at must produce at least one violation during store init"
-        )
-
-    def test_incident_shape_repair_attempted_immediately(self) -> None:
-        """Repair is attempted during __init__ — before any dispatch operation can run."""
-        store, cur = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],
-        )
-        # Repair SQL must have been called during __init__ — before test code runs
-        alter_calls = [
-            c for c in cur.execute.call_args_list if c.args and "ADD COLUMN IF NOT EXISTS claimed_at" in str(c.args[0])
-        ]
-        assert len(alter_calls) == 1, "Repair ALTER TABLE must be executed during store init, not deferred"
-        # Schema compat result is already set — not None — proving init completed check
-        assert store._schema_compat_result is not None
-
-    def test_incident_shape_successful_repair_yields_repaired_now(self) -> None:
-        """Successful repair of the incident drift → status=repaired_now (not incompatible_blocking)."""
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],  # claimed_at missing; repair succeeds (mock does not raise)
-        )
-        assert store._schema_compat_result.status == "repaired_now", (
-            "Successful claimed_at repair must produce repaired_now status"
-        )
-
-    def test_incident_shape_repaired_now_passes_gate(self) -> None:
-        """After successful repair (repaired_now), dispatch_schema_gate() must NOT raise.
-
-        This means the dispatch can proceed safely — old continuation path is no
-        longer needed and is explicitly prevented by the gate contract.
-        """
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],  # repair succeeds
-        )
-        assert store._schema_compat_result.status == "repaired_now"
-        # Must not raise — gate allows repaired_now through
-        dispatch_schema_gate(store)
-
-    def test_incident_shape_failed_repair_blocks_gate(self) -> None:
-        """When claimed_at repair fails, dispatch_schema_gate() raises DispatchSchemaIncompatibleError.
-
-        This is the hard-fail path: schema is incompatible and no repair is available,
-        so dispatch startup must be blocked before any state is created.
-        """
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],
-            repair_side_effect=Exception("permission denied"),
-        )
-        assert store._schema_compat_result.status == "incompatible_blocking"
-        with pytest.raises(DispatchSchemaIncompatibleError) as exc_info:
-            dispatch_schema_gate(store)
-        assert exc_info.value.compat_result.status == "incompatible_blocking"
-
-    def test_incident_shape_failed_repair_gate_error_names_cause(self) -> None:
-        """Gate error for failed repair must reference the dispatch_lanes.claimed_at violation."""
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],
-            repair_side_effect=Exception("permission denied"),
-        )
-        with pytest.raises(DispatchSchemaIncompatibleError) as exc_info:
-            dispatch_schema_gate(store)
-
-        compat = exc_info.value.compat_result
-        claimed_at_violations = [
-            v for v in compat.violations if v.table_name == "dispatch_lanes" and v.column_name == "claimed_at"
-        ]
-        assert len(claimed_at_violations) >= 1, "Gate error must carry a violation for dispatch_lanes.claimed_at"
-
-    def test_schema_compat_result_never_none_after_init(self) -> None:
-        """_schema_compat_result is always set after __init__ — no silent continuation path.
-
-        The old unsafe path depended on the schema mismatch going undetected in __init__
-        and surfacing only at INSERT time. The new contract guarantees _schema_compat_result
-        is populated during __init__ so callers can always gate on it.
-        """
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,
-            fetchall_columns=[],
-        )
-        assert store._schema_compat_result is not None, (
-            "_schema_compat_result must never be None after PostgresStateStore.__init__"
-        )
-        assert store._schema_compat_result.status in (
-            "compliant",
-            "repaired_now",
-            "incompatible_blocking",
-            "unreachable",
-        ), "status must be one of the four defined values"
-
-    def test_dispatch_lanes_table_present_but_column_missing_is_not_table_level_block(self) -> None:
-        """When dispatch_lanes exists but claimed_at is absent, violation is column-level (repair eligible).
-
-        The table-level check must NOT report dispatch_lanes as missing when it is present.
-        Only the claimed_at column violation should appear.
-        """
-        store, _ = _make_store_with_mock(
-            fetchall_tables=_ALL_DISPATCH_TABLES,  # dispatch_lanes IS present
-            fetchall_columns=[],  # claimed_at is absent
-        )
-        # After successful repair this is repaired_now; violations list shows what was repaired
-        result = store._schema_compat_result
-
-        # Verify: no SCHEMA_MISSING_TABLE violation for dispatch_lanes
-        missing_table_violations = [
-            v
-            for v in result.violations
-            if v.kind == SchemaIncompatibilityKind.SCHEMA_MISSING_TABLE and v.table_name == "dispatch_lanes"
-        ]
-        assert missing_table_violations == [], (
-            "dispatch_lanes is present; SCHEMA_MISSING_TABLE must not be raised for it"
-        )