fix: prod triage 2026-07-08 — MCP auth residue, gateway envelopes, verb-loop cap, A2A interjection, manual spawn UX (#334)

* fix(auth): pass agent UUID to CLI-arg MCP servers (optimal/docs/search)

The container token is HMAC-signed over the agent UUID (#314), but the
optimal/docs/search MCP servers received the slug as their CLI arg and
sent X-Agent-ID=<slug>, so every research/RAG/docs call 401ed with
signature mismatch under enforced auth. Pass the already-computed
agent_uuid in the three args lists instead.

* fix(gateway): include remediate in gateway.rejected audit details

Conventions-gate rejections carry the offending file:line listing only
in the envelope's remediate field, which the audit row dropped -- ops
logs showed just the violation count with no way to see what blocked.

* fix(gateway): return envelope on do/commit git failure

A GitError from the commit verb propagated to the generic middleware
handler, so agents got a raw error blob with no remediate/next. Catch
it and return an error envelope; 'no changes added to commit' with an
explicit files list now names the mismatch and the omit-files fallback.

* fix(agent-sdk): absolute rejection cap breaks slow-drip verb loops

The verb circuit breaker only counted rejections inside a 60s sliding
window, so an agent retrying i_am_done every 3-4 minutes looped for 30+
minutes without tripping it. Add a session-scoped cumulative per-(verb,
task) cap at 3x the windowed limit that trips regardless of pacing.

* feat(a2a): CEO chime-in interjects into the viewed conversation

Previously reply_as_ceo re-homed the message into a canonical CEO<->target
conversation with no panel surface, so a chime-in reported success but was
invisible and only opportunistically delivered. interject_as_ceo now inserts
the message into the conversation being viewed (from_agent=ceo, directed via
an @target content prefix), bumps that conversation's counters with the
unread ping keyed to the addressed participant, and both participants see it
in transcript and read_a2a.

* feat(panel): manual spawn carries task + message, surfaces refusals

The agent detail page spawned with no request body (task/message impossible),
the spawn button could double-fire (2.5ms double-POST seen live), and refusal
reasons never reached the UI: readiness refusals were generic 500s and the
already-running no-op looked like success. Detail page now uses
SpawnAgentDialog, a synchronous ref guard blocks re-entry, AgentReadinessError
maps to 409 with its reason shown, already_running is signalled and toasted,
and a task_id builds a task-aware prompt instructing the claim (task_id alone
never did), with the CEO's message appended as a note.

* test(panel): align a2a page test with the interjection footer copy

The chime-in rebuild changed the composer footer; the page-level test
asserting the old copy was outside the rebuild's scoped vitest run.

* fix(api): commit the request DB session before the response is sent

FastAPI unwinds yield-dependencies after the response bytes go out, so
get_db's post-yield commit raced the client's next request -- a verb
could return ok while its claim/status write was still uncommitted (the
e2e ok-without-effect flake family), and a failed commit was silently
lost behind an already-sent 200. DbCommitMiddleware (innermost, pure
ASGI) commits the session stashed by get_db_committed before forwarding
http.response.start; commit failure now surfaces as a 5xx. get_db is
untouched for its direct non-request callers.

* fix(db): invalidate, not rollback, the session on request cancellation

With the commit moved into the send path, the flow-verb timeout can
cancel mid-commit; rolling back then issues another command over an
asyncpg connection stranded mid-wire-protocol, and the poisoned
connection segfaults uvloop/asyncpg when a later checkout recycles it
(3/3 identical CI faulthandler dumps). On CancelledError discard the
connection via session.invalidate() -- SQLAlchemy's documented handling
for a timeout during commit -- and keep rollback for plain exceptions.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>

tests/integration/test_a2a_routes.py

@@ -1237,6 +1237,8 @@ async def test_admin_reply_no_task_id_400(a2a_route_client: dict) -> None:
 
 @pytest.mark.asyncio
 async def test_admin_reply_success(a2a_route_client: dict) -> None:
+    """The route posts into the VIEWED conversation via interject_as_ceo —
+    not a re-homed CEO<->target DM (the prior, rejected behavior)."""
     app = a2a_route_client["app"]
     dev = a2a_route_client["dev"]
     client = a2a_route_client["client"]
@@ -1249,7 +1251,7 @@ async def test_admin_reply_success(a2a_route_client: dict) -> None:
         id=uuid4(),
         conversation_id=conv_id,
         from_agent="ceo",
-        content="chiming in",
+        content="@be-dev-1: chiming in",
         message_kind="message",
         response_to_id=None,
         requires_response=False,
@@ -1260,7 +1262,7 @@ async def test_admin_reply_success(a2a_route_client: dict) -> None:
     with patch("roboco.api.routes.a2a.A2AService") as mock_service_cls:
         instance = AsyncMock()
         instance.get_conversation_admin = AsyncMock(return_value=conv)
-        instance.send = AsyncMock(return_value=sent_msg)
+        instance.interject_as_ceo = AsyncMock(return_value=sent_msg)
         mock_service_cls.return_value = instance
         response = await client.post(
             f"/api/a2a/chat/admin/conversations/{conv_id}/reply",
@@ -1268,44 +1270,13 @@ async def test_admin_reply_success(a2a_route_client: dict) -> None:
             headers=_HDR,
         )
     assert response.status_code == HTTPStatus.CREATED
-    instance.send.assert_awaited_once()
-    call_kwargs = instance.send.await_args.kwargs
+    instance.interject_as_ceo.assert_awaited_once()
+    call_kwargs = instance.interject_as_ceo.await_args.kwargs
+    assert call_kwargs["conversation_id"] == conv_id
     assert call_kwargs["to_agent"] == "be-dev-1"
-    assert call_kwargs["task_id"] == task_id
-    assert call_kwargs["body"] == "chiming in"
+    assert call_kwargs["content"] == "chiming in"
     body = response.json()
-    assert body["content"] == "chiming in"
-
-
-@pytest.mark.asyncio
-async def test_admin_reply_access_denied_maps_to_403(a2a_route_client: dict) -> None:
-    """Defensive: if send() ever rejects a CEO-authored A2A, surface 403
-    rather than crash — mirrors create_conversation's handling."""
-    app = a2a_route_client["app"]
-    dev = a2a_route_client["dev"]
-    client = a2a_route_client["client"]
-    _set_ceo_context(app, dev)
-
-    conv_id = uuid4()
-    task_id = uuid4()
-    conv = _admin_conv_obj(conv_id=conv_id, task_id=task_id)
-    with patch("roboco.api.routes.a2a.A2AService") as mock_service_cls:
-        instance = AsyncMock()
-        instance.get_conversation_admin = AsyncMock(return_value=conv)
-        instance.send = AsyncMock(
-            side_effect=A2AAccessDeniedError(
-                from_agent="ceo",
-                to_agent="be-dev-1",
-                reason="denied",
-            )
-        )
-        mock_service_cls.return_value = instance
-        response = await client.post(
-            f"/api/a2a/chat/admin/conversations/{conv_id}/reply",
-            json={"to_agent": "be-dev-1", "content": "hi"},
-            headers=_HDR,
-        )
-    assert response.status_code == HTTPStatus.FORBIDDEN
+    assert body["content"] == "@be-dev-1: chiming in"
 
 
 # ---------------------------------------------------------------------------