meshcode 2.11.6__tar.gz → 2.11.7__tar.gz

{meshcode-2.11.6 → meshcode-2.11.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.6
+Version: 2.11.7
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.6 → meshcode-2.11.7}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.6"
+__version__ = "2.11.7"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.6 → meshcode-2.11.7}/meshcode/meshcode_mcp/server.py

@@ -968,6 +968,90 @@ def with_working_status(func):
         return swrapper
 
 
+# ============================================================
+# Consequential-tool gate (task b4befbfd item 1 — epistemic V1)
+# ============================================================
+# Tools listed below refuse to run unless the calling agent has an open
+# decision in mc_traces from the last 5 minutes (logged via meshcode_decide).
+# Drives the team toward explicit pre-decision logging on hard-to-reverse
+# actions. Whitelist is overridable via mc_meshwork_memory key
+# `consequential_tool_whitelist` (future config; v1 uses the bake-in below
+# so commanders don't need to seed-bootstrap before the gate works).
+
+_CONSEQUENTIAL_TOOLS_DEFAULT = frozenset([
+    # Mesh-wide / cross-agent destructive
+    "meshcode_done",                  # broadcasts DONE to ALL agents
+    "meshcode_disconnect_agent",      # offlines another agent
+    "meshcode_edit_agent",            # mutates another agent's identity/role
+    "meshcode_edit_memory",           # writes into another agent's memory
+    "meshcode_forget",                # deletes memory (tombstones it)
+    "meshcode_create_meshwork",       # creates a new meshwork (hard to unwind)
+    "meshcode_marketplace_install",   # installs external code into project
+    "meshcode_publish_template",      # publishes a template publicly
+    "meshcode_proposal_convert",      # converts proposal into a real task
+    "meshcode_proposal_reject",       # rejects a proposal permanently
+    "meshcode_task_cancel",           # cancels a task (irreversible terminal state)
+])
+
+
+def _is_consequential(tool_name: str) -> bool:
+    """V1 reads the bake-in set. Future: lazy-load mc_meshwork_memory
+    `consequential_tool_whitelist` and merge. Soft-fail to the bake-in if
+    the RPC is unavailable so the gate never blocks itself out."""
+    return tool_name in _CONSEQUENTIAL_TOOLS_DEFAULT
+
+
+def _check_decision_gate(tool_name: str) -> Optional[Dict[str, Any]]:
+    """Returns None when the gate is open; returns an error dict to be
+    surfaced as the tool result when the gate is closed. Soft-fail on RPC
+    error (gate opens) so a transient DB blip doesn't trap the agent."""
+    if not _is_consequential(tool_name):
+        return None
+    try:
+        resp = be.sb_rpc("mc_has_open_decision", {
+            "p_api_key": _get_api_key(),
+            "p_project_id": _PROJECT_ID,
+            "p_agent_name": AGENT_NAME,
+        })
+        if isinstance(resp, dict) and resp.get("ok") and not resp.get("has_open_decision"):
+            return {
+                "ok": False,
+                "error_code": "decision_required",
+                "hint": (
+                    f"`{tool_name}` is a consequential action. Call "
+                    f"meshcode_decide(decision, alternatives, evidence_refs) "
+                    f"first so the team can learn from the outcome. After "
+                    f"the action is observable, call meshcode_outcome(trace_id, ...)."
+                ),
+                "consequential_tool": tool_name,
+            }
+    except Exception as _gate_err:
+        log.debug(f"decision gate soft-fail for {tool_name}: {_gate_err}")
+    return None
+
+
+def with_decision_gate(func):
+    """Decorator: applies _check_decision_gate before calling func. Use
+    AFTER @mcp.tool() and AFTER @with_working_status so the gate runs
+    inside the working-status window (and shows up in tool_call logs)."""
+    name = func.__name__
+    if asyncio.iscoroutinefunction(func):
+        @_functools.wraps(func)
+        async def awrapper(*args, **kwargs):
+            blocked = _check_decision_gate(name)
+            if blocked is not None:
+                return blocked
+            return await func(*args, **kwargs)
+        return awrapper
+    @_functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        blocked = _check_decision_gate(name)
+        if blocked is not None:
+            return blocked
+        return func(*args, **kwargs)
+    return wrapper
+
+
 # ============================================================
 # Single-instance lease — prevent split-brain when two windows
 # run `meshcode run <same-agent>` simultaneously.
@@ -1388,28 +1472,51 @@ def _log_crash_to_db(reason: str = "unknown", error_detail: str = "") -> None:
 # ============================================================
 # Agent identity from Supabase profile (for system instructions)
 # ============================================================
+# MIG-PLAN-A 2026-05-18: profile fetch moved out of module-import time
+# (was the last be.sb_rpc here that ran on import). Now starts as
+# placeholders; BG thread spawned by lifespan calls mc_agent_get_profile
+# and updates the globals. _build_instructions() runs at import using
+# whatever is currently in the globals — for first-boot of a fresh agent
+# this means InitializeResult.instructions carries empty launch_prompt /
+# fallback role_description; first-tool-call envelope can re-inject if
+# needed. Net win: zero network I/O at module-import time → MCP
+# handshake never blocks on profile fetch.
 
 _LAUNCH_PROMPT = ""
 _ROLE_DESCRIPTION = AGENT_ROLE or ""
-try:
-    _profile = be.sb_rpc("mc_agent_get_profile", {
-        "p_project_id": _PROJECT_ID,
-        "p_agent_name": AGENT_NAME,
-    })
-    if isinstance(_profile, list) and _profile:
-        _profile = _profile[0]
-    if isinstance(_profile, dict):
-        _inner = _profile.get("profile") if isinstance(_profile.get("profile"), dict) else _profile
-        _LAUNCH_PROMPT = (_inner.get("launch_prompt") or _profile.get("launch_prompt") or "") if isinstance(_inner, dict) else ""
-        _ROLE_DESCRIPTION = (
-            (_inner.get("role_description") if isinstance(_inner, dict) else None)
-            or _profile.get("role_description")
-            or _profile.get("role")
-            or AGENT_ROLE
-            or "(unspecified)"
-        )
-except Exception as _e:
-    log.warning(f"could not fetch agent profile: {_e}")
+
+def _load_agent_profile_bg() -> None:
+    """Run by daemon thread from lifespan. Populates _LAUNCH_PROMPT +
+    _ROLE_DESCRIPTION from mc_agent_get_profile. Soft-fail: log only.
+    Note: _INSTRUCTIONS has already been emitted by the time this runs,
+    so values landing here are surfaced to the agent only via tools that
+    read the globals later (most do not — _build_instructions is the only
+    real consumer)."""
+    global _LAUNCH_PROMPT, _ROLE_DESCRIPTION
+    try:
+        prof = be.sb_rpc("mc_agent_get_profile", {
+            "p_project_id": _PROJECT_ID,
+            "p_agent_name": AGENT_NAME,
+        })
+        if isinstance(prof, list) and prof:
+            prof = prof[0]
+        if isinstance(prof, dict):
+            inner = prof.get("profile") if isinstance(prof.get("profile"), dict) else prof
+            lp = ((inner.get("launch_prompt") if isinstance(inner, dict) else None)
+                  or prof.get("launch_prompt") or "")
+            rd = ((inner.get("role_description") if isinstance(inner, dict) else None)
+                  or prof.get("role_description")
+                  or prof.get("role")
+                  or AGENT_ROLE
+                  or "(unspecified)")
+            _LAUNCH_PROMPT = lp
+            _ROLE_DESCRIPTION = rd
+            log.info(
+                f"agent profile loaded (bg): role='{_ROLE_DESCRIPTION[:60]}' "
+                f"launch_prompt_len={len(_LAUNCH_PROMPT)}"
+            )
+    except Exception as _e:
+        log.warning(f"could not fetch agent profile (bg): {_e}")
 
 
 # ── Leader/commander detection (single source of truth) ───────
@@ -1502,6 +1609,91 @@ if _INSTRUCTIONS_BUILD_NS > 500_000_000:
         f"Investigate any be.sb_rpc / network I/O added to _build_instructions()."
     )
 
+# ============================================================
+# Install-guard (task dbae99ed 2026-05-18) — detect mid-session
+# pip --force-reinstall over the running env and execv-restart cleanly
+# instead of crashing on lockfile collision. Class:
+# feedback_pip_install_into_live_mcp_env_self_kill weight 9.
+# Paired with stop_hook _mcp_disconnected_without_reconnect (P0 mig
+# 68a3545e) so the brief MCP-socket-drop during execv doesn't trap the
+# Claude Code agent.
+# ============================================================
+from pathlib import Path as _Path  # local-scope; rest of module doesn't need it
+_PKG_DIR = _Path(__file__).resolve().parent.parent  # .../site-packages/meshcode/
+
+def _snapshot_pkg_mtimes():
+    out = {}
+    try:
+        for p in _PKG_DIR.rglob("*.py"):
+            try:
+                out[str(p)] = p.stat().st_mtime
+            except OSError:
+                continue
+    except Exception:
+        pass
+    return out
+
+_PKG_PY_MTIMES = _snapshot_pkg_mtimes()
+log.info(f"install-guard: snapshotted {len(_PKG_PY_MTIMES)} *.py mtimes under {_PKG_DIR}")
+
+
+def _install_guard_check() -> None:
+    """Heartbeat-tick scan: if any *.py under the meshcode pkg path has
+    a fresher mtime than recorded at boot, the env was reinstalled while
+    the process is alive (class feedback_pip_install_into_live_mcp_env_self_kill).
+    The running image holds stale bytecode; lockfile collision and
+    orphan-watchdog will eventually kill us anyway. Pre-empt: release the
+    lease and execv-restart so the new wheel is picked up cleanly.
+
+    The MCP socket to Claude Code WILL drop during the exec window.
+    Stop_hook _mcp_disconnected_without_reconnect (mig 68a3545e) catches
+    it; user runs `meshcode go <agent>` to pick up the new wheel.
+
+    Soft-fail throughout: any exception here is logged and swallowed so
+    the heartbeat thread isn't taken down by a flaky filesystem call.
+    """
+    if not _PKG_PY_MTIMES:
+        return
+    try:
+        for path, old_mtime in list(_PKG_PY_MTIMES.items()):
+            try:
+                new_mtime = os.path.getmtime(path)
+            except OSError:
+                continue
+            # 0.5s slack — covers fs-timestamp resolution and tar extract
+            # re-emit jitter without false-positive on intentional touch.
+            if new_mtime <= old_mtime + 0.5:
+                continue
+            log.warning(
+                f"install-guard: self-modification detected on {path} "
+                f"(mtime {old_mtime:.0f} → {new_mtime:.0f}). The running "
+                f"image holds stale bytecode; triggering clean execv-restart "
+                f"so the new wheel is picked up. MCP socket will drop briefly "
+                f"— stop_hook handles the agent release (mig 68a3545e). User "
+                f"runs `meshcode go <agent>` to relaunch under the new image. "
+                f"Class: feedback_pip_install_into_live_mcp_env_self_kill."
+            )
+            try:
+                _release_lease_synchronous(timeout_s=1.5)
+            except Exception:
+                pass
+            _heartbeat_stop.set()
+            # execv replaces the current process; daemon threads die with
+            # it; new process inherits stdio. We pass the original argv so
+            # the entry-point command line is preserved verbatim.
+            try:
+                os.execv(sys.executable, [sys.executable] + sys.argv)
+            except Exception as _exec_err:
+                log.error(
+                    f"install-guard execv failed ({_exec_err}); "
+                    f"falling back to os._exit(0). Lifespan finally + "
+                    f"stop_hook still recover."
+                )
+                os._exit(0)
+            return  # unreachable but explicit
+    except Exception as e:
+        log.debug(f"install-guard scan failed (soft): {e}")
+
 # MIG-PLAN-A 2026-05-18: memory pre-load deferred to BG daemon thread.
 # Was synchronous mc_memory_list (critical+reference tiers + legacy fallback)
 # that appended to module-global _INSTRUCTIONS at import time. On commander-
@@ -1845,6 +2037,11 @@ def _heartbeat_loop_inner():
             except Exception:
                 pass
 
+            # Install-guard tick (task dbae99ed). Cheap mtime scan over
+            # ~100-200 *.py files; if any changed since boot, we execv-
+            # restart cleanly before lockfile collision kills us.
+            _install_guard_check()
+
             _hb_resp = be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": _SDK_VERSION})
 
             # Tombstone gate (mig 211): user disconnected this agent.
@@ -2106,6 +2303,10 @@ async def lifespan(_app):
     # MIG-PLAN-A 2026-05-18: memory pre-load deferred from module-import-time
     # to here. Soft-fail consumers read from _PRELOADED_CRITICAL / _PRELOADED_REFERENCE_KEYS.
     _threading.Thread(target=_preload_memories_bg, daemon=True, name="meshcode-preload-memories").start()
+    # MIG-PLAN-A 2026-05-18 part 2: agent profile fetch deferred. Was the
+    # last be.sb_rpc that ran at module-import time. Closes the import-time
+    # zero-network goal for the CI regression sentinel.
+    _threading.Thread(target=_load_agent_profile_bg, daemon=True, name="meshcode-load-profile").start()
 
     # Heartbeat in daemon thread — independent of asyncio event loop.
     _heartbeat_stop.clear()
@@ -3343,6 +3544,7 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
 
 @mcp.tool()
 @with_working_status
+@with_decision_gate
 def meshcode_done(reason: str) -> Dict[str, Any]:
     """Broadcast DONE to all agents — exits everyone's wait loop.
 
@@ -4605,6 +4807,7 @@ def meshcode_edit_agent(name: str, role: Optional[str] = None, launch_prompt: Op
 
 @mcp.tool()
 @with_working_status
+@with_decision_gate
 def meshcode_edit_memory(agent_name: str, key: str, value: Any) -> Dict[str, Any]:
     """Edit another agent's memory (for commanders coordinating the team).
 
@@ -4833,6 +5036,7 @@ def meshcode_recall_keys() -> Dict[str, Any]:
 
 @mcp.tool()
 @with_working_status
+@with_decision_gate
 def meshcode_forget(key: str) -> Dict[str, Any]:
     """Delete a stored memory.
 

{meshcode-2.11.6 → meshcode-2.11.7}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.6
+Version: 2.11.7
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.6 → meshcode-2.11.7}/meshcode.egg-info/SOURCES.txt

@@ -190,10 +190,13 @@ meshcode/meshcode_mcp/test_server_wrapper.py
 meshcode/scripts/check_secrets.py
 meshcode/scripts/race_rate_harness.py
 tests/test_auto_update_hardening.py
+tests/test_boot_bug_regression.py
 tests/test_core.py
 tests/test_cross_agent_messaging.py
+tests/test_epistemic_v1_stop_conditions.py
 tests/test_esc_deaf_state.py
 tests/test_exceptions.py
+tests/test_install_guard.py
 tests/test_lease_sigterm_release.py
 tests/test_mark_read_batch.py
 tests/test_migration_integrity.py

{meshcode-2.11.6 → meshcode-2.11.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.6"
+version = "2.11.7"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}

meshcode-2.11.7/tests/test_boot_bug_regression.py

@@ -0,0 +1,205 @@
+"""
+Boot-bug regression sentinels (task abae2997 → closes the class identified in
+memory project_mesh_commander_mcp_failed_at_launch weight 10).
+
+Two tests, one per RC of the 2026-05-18 boot bug:
+
+(a) IMPORT-TIME RPC ALLOWLIST
+    Spawns a subprocess that:
+      - Monkeypatches meshcode.meshcode_mcp.backend.sb_rpc to record every
+        call name. Then ALLOWS only an explicit whitelist (currently:
+        mc_register_agent — required for agent identity at startup), and
+        raises on anything else.
+      - Sets the minimum env vars so the import doesn't legitimately fall
+        through to the mc_resolve_project path.
+      - Imports meshcode.meshcode_mcp.server.
+      - Asserts the import completes and no NON-WHITELISTED RPC was called
+        at module-import time. Catches drift toward the Claude Code MCP-
+        handshake window (Plan A bug, RC #2).
+
+    To widen the whitelist intentionally, add to ALLOWED_IMPORT_RPCS below
+    AND document why in the comment block. Most import-time RPCs are bugs
+    waiting to happen — keep the list as short as possible.
+
+(b) REGISTER-ALL-VALID-STATUSES
+    Live-DB test (skips without env vars). Reads public.mc_agent_all_statuses()
+    from prod, attempts mc_register_agent with each value (inside a transaction
+    that rolls back). Asserts no 23514 / valid_agent_status CHECK violation.
+    This catches future SDK↔DDL enum drift like the 'needs_launch' incident
+    (mig 312 bug, RC #1).
+
+Usage:
+    pytest tests/test_boot_bug_regression.py -v
+
+    # live test only:
+    MESHCODE_SUPABASE_URL=https://...supabase.co \\
+    MESHCODE_SUPABASE_ANON_KEY=sb_publishable_... \\
+    MESHCODE_PROJECT_ID=... \\
+    pytest tests/test_boot_bug_regression.py::test_register_all_valid_statuses_live -v
+"""
+
+import os
+import subprocess
+import sys
+import textwrap
+import uuid
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).parent.parent
+
+
+def test_module_import_rpc_allowlist():
+    """RC #2 sentinel — Plan A. Fails if a NON-WHITELISTED be.sb_rpc is
+    called at module-import time. That class of call breaks MCP handshake
+    on heavy-memory agents."""
+    snippet = textwrap.dedent(
+        """
+        import os, sys
+        os.environ.setdefault('MESHCODE_PROJECT', 'meshcode-self-improve')
+        os.environ.setdefault('MESHCODE_AGENT', 'backend')
+        os.environ.setdefault('MESHCODE_PROJECT_ID',
+            '00000000-0000-0000-0000-000000000000')
+        os.environ.setdefault('MESHCODE_SUPABASE_URL', 'https://fake.local')
+        os.environ.setdefault('MESHCODE_SUPABASE_ANON_KEY', 'fake_anon')
+
+        # Allow-list: RPCs that may legitimately run at module-import time.
+        # Keep this list as short as possible — most additions indicate a
+        # latent boot-bug. Document each entry's reason.
+        ALLOWED_IMPORT_RPCS = {
+            # mc_register_agent: agent identity must exist before the first
+            # tool call; lazy-registering on first call would mean tools
+            # can fire from a non-existent agent_id. Tolerated at boot;
+            # response is small (single row insert/upsert).
+            'mc_register_agent',
+            # mc_release_agent_lease: post-SIGKILL stale-lease release.
+            # Only fires when _kill_stale_mcp_process found a prior dead
+            # process. Single-row update; latency negligible.
+            'mc_release_agent_lease',
+            # mc_memory_get: restore inbox watermark (last_seen). Single-
+            # row lookup; cheap. Could be deferred to first meshcode_check
+            # but the value is needed before the first wait() returns.
+            'mc_memory_get',
+        }
+
+        import meshcode.meshcode_mcp.backend as be
+        _calls = []
+
+        def _gated(name, *a, **kw):
+            _calls.append(name)
+            if name not in ALLOWED_IMPORT_RPCS:
+                raise RuntimeError(
+                    'MODULE_IMPORT_RPC_LEAK: be.sb_rpc called at module-import '
+                    f'time with NON-WHITELISTED rpc={name!r}. '
+                    'If this is intentional, defer to lifespan BG thread '
+                    '(see _load_persona_bg pattern) or add to ALLOWED_IMPORT_RPCS '
+                    'with rationale.'
+                )
+            # Return a minimal-shape ok response so import flow completes.
+            return {'ok': True, 'id': None}
+
+        be.sb_rpc = _gated
+
+        import meshcode.meshcode_mcp.server  # noqa: F401
+        print(f'IMPORT_OK calls={_calls}')
+        """
+    )
+
+    result = subprocess.run(
+        [sys.executable, '-c', snippet],
+        capture_output=True,
+        text=True,
+        cwd=REPO_ROOT,
+        timeout=30,
+    )
+
+    # meshcode boot prints to stderr by design; combine both streams for the
+    # IMPORT_OK / leak markers.
+    combined = (result.stdout or '') + '\n' + (result.stderr or '')
+    assert result.returncode == 0, (
+        f"Module import subprocess crashed.\n"
+        f"--- stdout ---\n{result.stdout}\n"
+        f"--- stderr ---\n{result.stderr}"
+    )
+    assert 'IMPORT_OK' in combined, (
+        f"Module import did not complete cleanly:\n{combined}"
+    )
+    assert 'MODULE_IMPORT_RPC_LEAK' not in combined, (
+        f"Non-whitelisted be.sb_rpc fired at module-import time. "
+        f"This breaks MCP handshake on heavy-memory agents.\n{combined}"
+    )
+
+
+def test_register_all_valid_statuses_live():
+    """RC #1 sentinel — mig 312. Catches SDK↔DDL enum drift like the
+    'needs_launch' incident.
+
+    Live-only. Reads public.mc_agent_all_statuses() and tries each value via
+    mc_register_agent inside a savepoint-rolled-back transaction so no real
+    agents are created. Assertion: no 23514 CHECK constraint violation.
+    """
+    pat = os.environ.get('MESHCODE_SUPABASE_MGMT_PAT') or os.environ.get('SUPABASE_PAT')
+    project_ref = (
+        os.environ.get('MESHCODE_SUPABASE_PROJECT_REF')
+        or os.environ.get('SUPABASE_PROJECT_REF')
+        or 'gjinagyyjttyxnaoavnz'
+    )
+    project_id = os.environ.get('MESHCODE_PROJECT_ID')
+
+    if not (pat and project_id):
+        pytest.skip(
+            'MESHCODE_SUPABASE_MGMT_PAT + MESHCODE_PROJECT_ID required for live '
+            'register-all-statuses test'
+        )
+
+    import json
+    import urllib.request
+
+    def run_sql(sql: str) -> object:
+        req = urllib.request.Request(
+            f'https://api.supabase.com/v1/projects/{project_ref}/database/query',
+            data=json.dumps({'query': sql}).encode('utf-8'),
+            headers={
+                'Authorization': f'Bearer {pat}',
+                'Content-Type': 'application/json',
+            },
+            method='POST',
+        )
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return json.loads(r.read())
+
+    rows = run_sql("SELECT unnest(public.mc_agent_all_statuses()) AS status;")
+    statuses = [r['status'] for r in rows if isinstance(r, dict) and 'status' in r]
+    assert statuses, f'public.mc_agent_all_statuses() returned no rows: {rows!r}'
+
+    failures = []
+    for st in statuses:
+        marker = f'__sentinel_{uuid.uuid4().hex[:8]}__'
+        sql = (
+            "BEGIN; "
+            f"INSERT INTO meshcode.mc_agents (project_id, name, role, status, "
+            f"registered_at, last_heartbeat) VALUES "
+            f"('{project_id}'::uuid, '{marker}', 'sentinel', '{st}', now(), now()) "
+            f"RETURNING status; "
+            "ROLLBACK;"
+        )
+        try:
+            res = run_sql(sql)
+        except urllib.error.HTTPError as e:
+            body = e.read().decode('utf-8', 'replace')
+            failures.append((st, f'HTTP {e.code}: {body[:200]}'))
+            continue
+
+        # Mgmt API returns either a list of rows or {"message": "..."} on err
+        if isinstance(res, dict) and 'message' in res:
+            msg = res['message']
+            # Tolerate name-format CHECK or other unrelated checks; the
+            # status CHECK is the one we care about.
+            if 'valid_agent_status' in msg or '23514' in msg and 'status' in msg:
+                failures.append((st, msg[:200]))
+
+    assert not failures, (
+        'SDK↔DDL enum drift detected — some statuses fail valid_agent_status '
+        f'CHECK:\n{failures}'
+    )