test(handlers): add HTTP handler tests for GetA2AQueueStatus and PatchAbilities

GetA2AQueueStatus (9 cases):
- queue_id empty → 400 (via gin.CreateTestContext to bypass router)
- no identity, no org token → 404 (existence-non-inference policy)
- org token set → skips caller workspace check (authorized)
- caller workspace matches caller_id → 200
- caller workspace matches workspace_id → 200
- queue not found (sql.ErrNoRows) → 404
- queue auth-fields DB error → 500
- wrong caller workspace → 404 (IDOR collapsed to 404)
- status fetch DB error → 500
- full happy path → 200 with JSON body

PatchAbilities (11 cases):
- invalid workspace ID → 400
- invalid request body → 400
- no ability fields → 400
- workspace not found (ErrNoRows) → 404
- workspace not found (exists=false) → 404
- update broadcast_enabled=true → 200
- update talk_to_user_enabled=false → 200
- update both abilities → 200
- broadcast_enabled DB error → 500
- talk_to_user_enabled DB error → 500

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

workspace-server/internal/handlers/a2a_queue_status_handler_test.go

@@ -0,0 +1,408 @@
+package handlers
+
+import (
+	"database/sql"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
+	"github.com/gin-gonic/gin"
+)
+
+// setupQueueStatusHandlerDB creates a sqlmock DB with QueryMatcherEqual for exact SQL string matching.
+func setupQueueStatusHandlerDB(t *testing.T) sqlmock.Sqlmock {
+	t.Helper()
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("sqlmock.New: %v", err)
+	}
+	prevDB := db.DB
+	db.DB = mockDB
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+	return mock
+}
+
+// Exact SQL strings used by the production code.
+const (
+	sqlQueueRowAuthFields = `SELECT caller_id, workspace_id FROM a2a_queue WHERE id = $1`
+	sqlQueueStatusByID    = `
+		SELECT
+			q.id,
+			q.workspace_id,
+			q.status,
+			q.priority,
+			q.attempts,
+			q.last_error,
+			q.enqueued_at::text,
+			q.dispatched_at::text,
+			q.completed_at::text,
+			q.expires_at::text,
+			al.response_body::text
+		FROM a2a_queue q
+		LEFT JOIN activity_logs al
+			ON al.method = 'delegate_result'
+			AND al.target_id = q.workspace_id
+			AND al.workspace_id = q.caller_id
+			AND al.response_body->>'delegation_id' = (q.body->'params'->'message'->'metadata'->>'delegation_id')
+		WHERE q.id = $1`
+)
+
+// ── GetA2AQueueStatus HTTP handler tests ──────────────────────────────────────
+
+// TestGetA2AQueueStatus_QueueIDEmpty_Returns400 exercises the handler directly
+// (not via router) so we can verify the empty-value branch without relying on
+// Gin route-matching behaviour.
+func TestGetA2AQueueStatus_QueueIDEmpty_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"}}
+	// queue_id param is empty string
+	c.Params = gin.Params{
+		{Key: "id", Value: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"},
+		{Key: "queue_id", Value: ""},
+	}
+	c.Request = httptest.NewRequest(http.MethodGet, "/", nil)
+
+	h.GetA2AQueueStatus(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400", w.Code)
+	}
+}
+
+func TestGetA2AQueueStatus_NoIdentity_NoOrgToken_Returns404(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/wsid/a2a/queue/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	// No identity derivable → 404 (not 401) per existence-non-inference policy.
+	if w.Code != http.StatusNotFound {
+		t.Errorf("got %d, want 404", w.Code)
+	}
+}
+
+func TestGetA2AQueueStatus_OrgToken_SkipsCallerCheck(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	authRows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow("other-ws", wsID)
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnRows(authRows)
+
+	statusRows := sqlmock.NewRows([]string{
+		"id", "workspace_id", "status", "priority", "attempts",
+		"last_error", "enqueued_at", "dispatched_at", "completed_at", "expires_at",
+		"response_body",
+	}).AddRow(
+		queueID, wsID, "queued", 50, 0,
+		nil, "2026-01-01T00:00:00Z", nil, nil, nil, nil,
+	)
+	mock.ExpectQuery(sqlQueueStatusByID).
+		WithArgs(queueID).
+		WillReturnRows(statusRows)
+
+	r := gin.New()
+	// Simulate org-token middleware setting org_token_id.
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", func(c *gin.Context) {
+		c.Set("org_token_id", "org-admin")
+		h.GetA2AQueueStatus(c)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/workspaces/wsid/a2a/queue/"+queueID, nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_CallerWorkspaceMatchesCallerID_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	authRows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow(callerID, wsID)
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnRows(authRows)
+
+	statusRows := sqlmock.NewRows([]string{
+		"id", "workspace_id", "status", "priority", "attempts",
+		"last_error", "enqueued_at", "dispatched_at", "completed_at", "expires_at",
+		"response_body",
+	}).AddRow(
+		queueID, wsID, "completed", 50, 1,
+		nil, "2026-01-01T00:00:00Z", "2026-01-01T00:01:00Z", "2026-01-01T00:02:00Z",
+		nil, []byte(`{"text":"result"}`),
+	)
+	mock.ExpectQuery(sqlQueueStatusByID).
+		WithArgs(queueID).
+		WillReturnRows(statusRows)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", callerID)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_CallerWorkspaceMatchesWorkspaceID_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	authRows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow(callerID, wsID)
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnRows(authRows)
+
+	statusRows := sqlmock.NewRows([]string{
+		"id", "workspace_id", "status", "priority", "attempts",
+		"last_error", "enqueued_at", "dispatched_at", "completed_at", "expires_at",
+		"response_body",
+	}).AddRow(
+		queueID, wsID, "queued", 50, 0,
+		nil, "2026-01-01T00:00:00Z", nil, nil, nil, nil,
+	)
+	mock.ExpectQuery(sqlQueueStatusByID).
+		WithArgs(queueID).
+		WillReturnRows(statusRows)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", wsID)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_QueueNotFound_Returns404(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrNoRows)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", callerID)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("got %d, want 404: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_QueueAuthFieldsDBError_Returns500(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrConnDone)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", callerID)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("got %d, want 500: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_WrongCallerWorkspace_Returns404(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+	wrongCaller := "dddddddd-dddd-dddd-dddd-dddddddddddd"
+
+	authRows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow(callerID, wsID)
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnRows(authRows)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", wrongCaller)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("got %d, want 404: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_StatusFetchDBError_Returns500(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	authRows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow(callerID, wsID)
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnRows(authRows)
+
+	mock.ExpectQuery(sqlQueueStatusByID).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrConnDone)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", callerID)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("got %d, want 500: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestGetA2AQueueStatus_FullHappyPath_ReturnsJSON(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupQueueStatusHandlerDB(t)
+	h := &WorkspaceHandler{}
+
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	authRows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow(callerID, wsID)
+	mock.ExpectQuery(sqlQueueRowAuthFields).
+		WithArgs(queueID).
+		WillReturnRows(authRows)
+
+	respBody := []byte(`{"text":"delegation result"}`)
+	statusRows := sqlmock.NewRows([]string{
+		"id", "workspace_id", "status", "priority", "attempts",
+		"last_error", "enqueued_at", "dispatched_at", "completed_at", "expires_at",
+		"response_body",
+	}).AddRow(
+		queueID, wsID, "completed", 50, 1,
+		nil, "2026-01-01T00:00:00Z", "2026-01-01T00:01:00Z", "2026-01-01T00:02:00Z",
+		nil, respBody,
+	)
+	mock.ExpectQuery(sqlQueueStatusByID).
+		WithArgs(queueID).
+		WillReturnRows(statusRows)
+
+	r := gin.New()
+	r.GET("/workspaces/:id/a2a/queue/:queue_id", h.GetA2AQueueStatus)
+
+	req := httptest.NewRequest(http.MethodGet,
+		"/workspaces/"+wsID+"/a2a/queue/"+queueID, nil)
+	req.Header.Set("X-Workspace-ID", wsID)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if w.Body.Len() == 0 {
+		t.Error("response body is empty")
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}

workspace-server/internal/handlers/workspace_abilities_test.go

@@ -0,0 +1,317 @@
+package handlers
+
+import (
+	"database/sql"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
+	"github.com/gin-gonic/gin"
+)
+
+// setupAbilitiesDB creates a sqlmock DB with QueryMatcherEqual for exact SQL matching.
+func setupAbilitiesDB(t *testing.T) sqlmock.Sqlmock {
+	t.Helper()
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("sqlmock.New: %v", err)
+	}
+	prevDB := db.DB
+	db.DB = mockDB
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+	return mock
+}
+
+// Exact SQL strings used by the production handler.
+const (
+	sqlPatchAbilitiesExists = `SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')`
+	sqlPatchBroadcastEnabled   = `UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1`
+	sqlPatchTalkToUserEnabled  = `UPDATE workspaces SET talk_to_user_enabled = $2, updated_at = now() WHERE id = $1`
+)
+
+// ── PatchAbilities HTTP handler tests ──────────────────────────────────────────
+
+func TestPatchAbilities_InvalidWorkspaceID_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupAbilitiesDB(t)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "not-a-uuid"}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/not-a-uuid/abilities", nil)
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400", w.Code)
+	}
+}
+
+func TestPatchAbilities_InvalidBody_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupAbilitiesDB(t)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"}}
+	c.Request = httptest.NewRequest(http.MethodPatch,
+		"/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa/abilities",
+		newFakeCloser([]byte("not json")))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400", w.Code)
+	}
+}
+
+func TestPatchAbilities_NoAbilityFields_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupAbilitiesDB(t)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"}}
+	c.Request = httptest.NewRequest(http.MethodPatch,
+		"/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa/abilities",
+		newFakeCloser([]byte(`{}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400", w.Code)
+	}
+}
+
+func TestPatchAbilities_WorkspaceNotFound_Returns404(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnError(sql.ErrNoRows)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"broadcast_enabled":true}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("got %d, want 404: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_WorkspaceNotFound_ExistsFalse_Returns404(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(false))
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"talk_to_user_enabled":false}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("got %d, want 404: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_UpdateBroadcastEnabled_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec(sqlPatchBroadcastEnabled).
+		WithArgs(wsID, true).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"broadcast_enabled":true}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_UpdateTalkToUserEnabled_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec(sqlPatchTalkToUserEnabled).
+		WithArgs(wsID, false).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"talk_to_user_enabled":false}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_UpdateBothAbilities_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec(sqlPatchBroadcastEnabled).
+		WithArgs(wsID, true).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	mock.ExpectExec(sqlPatchTalkToUserEnabled).
+		WithArgs(wsID, false).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"broadcast_enabled":true,"talk_to_user_enabled":false}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_BroadcastEnabledDBError_Returns500(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec(sqlPatchBroadcastEnabled).
+		WithArgs(wsID, true).
+		WillReturnError(sql.ErrConnDone)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"broadcast_enabled":true}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("got %d, want 500: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_TalkToUserEnabledDBError_Returns500(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupAbilitiesDB(t)
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlPatchAbilitiesExists).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec(sqlPatchTalkToUserEnabled).
+		WithArgs(wsID, true).
+		WillReturnError(sql.ErrConnDone)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodPatch, "/workspaces/"+wsID+"/abilities",
+		newFakeCloser([]byte(`{"talk_to_user_enabled":true}`)))
+	c.Request.Header.Set("Content-Type", "application/json")
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("got %d, want 500: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+// newFakeCloser wraps a byte slice as an io.ReadCloser for request body injection.
+func newFakeCloser(data []byte) *fakeReadCloser {
+	return &fakeReadCloser{data: data}
+}
+
+type fakeReadCloser struct {
+	data []byte
+	pos  int
+}
+
+func (f *fakeReadCloser) Read(p []byte) (n int, err error) {
+	if f.pos >= len(f.data) {
+		return 0, nil
+	}
+	n = copy(p, f.data[f.pos:])
+	f.pos += n
+	return n, nil
+}
+
+func (*fakeReadCloser) Close() error { return nil }

workspace-server/internal/handlers/workspace_broadcast_test.go

@@ -0,0 +1,403 @@
+package handlers
+
+import (
+	"database/sql"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
+	"github.com/gin-gonic/gin"
+)
+
+// broadcastBody is a convenience that returns an io.ReadCloser wrapping JSON body.
+func broadcastBody(body string) io.ReadCloser {
+	return &broadcastFakeCloser{data: []byte(body)}
+}
+
+type broadcastFakeCloser struct {
+	data []byte
+	pos  int
+}
+
+func (f *broadcastFakeCloser) Read(p []byte) (n int, err error) {
+	if f.pos >= len(f.data) {
+		return 0, io.EOF
+	}
+	n = copy(p, f.data[f.pos:])
+	f.pos += n
+	return n, nil
+}
+
+func (*broadcastFakeCloser) Close() error { return nil }
+
+// setupBroadcastDB creates a sqlmock DB with QueryMatcherEqual.
+func setupBroadcastDB(t *testing.T) sqlmock.Sqlmock {
+	t.Helper()
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("sqlmock.New: %v", err)
+	}
+	prevDB := db.DB
+	db.DB = mockDB
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+	return mock
+}
+
+// Exact SQL strings from the production handler (whitespace must match verbatim).
+const (
+	sqlBroadcastWorkspaceLookup = `SELECT name, broadcast_enabled FROM workspaces WHERE id = $1 AND status != 'removed'`
+	sqlBroadcastRecipients     = `SELECT id FROM workspaces WHERE status != 'removed' AND id != $1`
+	sqlBroadcastReceiveInsert  = `
+			INSERT INTO activity_logs (workspace_id, activity_type, method, source_id, summary, status)
+			VALUES ($1, 'broadcast_receive', 'broadcast', $2, $3, 'ok')`
+	sqlBroadcastSentInsert = `
+		INSERT INTO activity_logs (workspace_id, activity_type, method, summary, status)
+		VALUES ($1, 'broadcast_sent', 'broadcast', $2, 'ok')`
+)
+
+// ── Broadcast HTTP handler tests ───────────────────────────────────────────────
+
+func TestBroadcast_InvalidWorkspaceID_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/not-a-uuid/broadcast",
+		broadcastBody(`{"message":"hello"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestBroadcast_MissingMessage_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost,
+		"/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa/broadcast",
+		broadcastBody(`{}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestBroadcast_EmptyMessage_Returns400(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost,
+		"/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa/broadcast",
+		broadcastBody(`{"message":""}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("got %d, want 400: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestBroadcast_WorkspaceNotFound_Returns404(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlBroadcastWorkspaceLookup).
+		WithArgs(wsID).
+		WillReturnError(sql.ErrNoRows)
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/"+wsID+"/broadcast",
+		broadcastBody(`{"message":"hello"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("got %d, want 404: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestBroadcast_BroadcastDisabled_Returns403(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlBroadcastWorkspaceLookup).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("test-workspace", false))
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/"+wsID+"/broadcast",
+		broadcastBody(`{"message":"hello"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusForbidden {
+		t.Errorf("got %d, want 403: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestBroadcast_NoRecipients_Success(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlBroadcastWorkspaceLookup).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("test-workspace", true))
+
+	// No recipients (sender is the only non-removed workspace)
+	mock.ExpectQuery(sqlBroadcastRecipients).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}))
+
+	// Sender's own activity log: 2 args (workspaceID, summary)
+	mock.ExpectExec(sqlBroadcastSentInsert).
+		WithArgs(wsID, sqlmock.AnyArg()).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/"+wsID+"/broadcast",
+		broadcastBody(`{"message":"hello everyone"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestBroadcast_WithRecipients_Success_DeliversToAll(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	recipient1 := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	recipient2 := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	mock.ExpectQuery(sqlBroadcastWorkspaceLookup).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("broadcaster-ws", true))
+
+	mock.ExpectQuery(sqlBroadcastRecipients).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).
+			AddRow(recipient1).
+			AddRow(recipient2))
+
+	// broadcast_receive: 3 args (recipientID, senderID, summary)
+	mock.ExpectExec(sqlBroadcastReceiveInsert).
+		WithArgs(recipient1, sqlmock.AnyArg(), sqlmock.AnyArg()).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	mock.ExpectExec(sqlBroadcastReceiveInsert).
+		WithArgs(recipient2, sqlmock.AnyArg(), sqlmock.AnyArg()).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	// broadcast_sent: 2 args (workspaceID, summary)
+	mock.ExpectExec(sqlBroadcastSentInsert).
+		WithArgs(wsID, sqlmock.AnyArg()).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/"+wsID+"/broadcast",
+		broadcastBody(`{"message":"hello team"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestBroadcast_RecipientInsertError_ContinuesAndSucceeds(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	recipient1 := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	recipient2 := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	mock.ExpectQuery(sqlBroadcastWorkspaceLookup).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("broadcaster-ws", true))
+
+	mock.ExpectQuery(sqlBroadcastRecipients).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).
+			AddRow(recipient1).
+			AddRow(recipient2))
+
+	// First recipient insert fails — handler logs and continues
+	mock.ExpectExec(sqlBroadcastReceiveInsert).
+		WithArgs(recipient1, sqlmock.AnyArg(), sqlmock.AnyArg()).
+		WillReturnError(sql.ErrConnDone)
+
+	// Second recipient succeeds
+	mock.ExpectExec(sqlBroadcastReceiveInsert).
+		WithArgs(recipient2, sqlmock.AnyArg(), sqlmock.AnyArg()).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	mock.ExpectExec(sqlBroadcastSentInsert).
+		WithArgs(wsID, sqlmock.AnyArg()).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/"+wsID+"/broadcast",
+		broadcastBody(`{"message":"partial delivery"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestBroadcast_SenderActivityLogError_StillReturns200(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	mock := setupBroadcastDB(t)
+	h := NewBroadcastHandler(newTestBroadcaster())
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(sqlBroadcastWorkspaceLookup).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("broadcaster-ws", true))
+
+	mock.ExpectQuery(sqlBroadcastRecipients).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}))
+
+	mock.ExpectExec(sqlBroadcastSentInsert).
+		WithArgs(wsID, sqlmock.AnyArg()).
+		WillReturnError(sql.ErrConnDone)
+
+	r := gin.New()
+	r.POST("/workspaces/:id/broadcast", h.Broadcast)
+
+	req := httptest.NewRequest(http.MethodPost, "/workspaces/"+wsID+"/broadcast",
+		broadcastBody(`{"message":"hello"}`))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	// Handler logs error but still returns 200
+	if w.Code != http.StatusOK {
+		t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+// ── broadcastTruncate pure function tests ─────────────────────────────────────
+
+func TestBroadcastTruncate_UnderLimit(t *testing.T) {
+	input := "short message"
+	got := broadcastTruncate(input, 50)
+	if got != input {
+		t.Errorf("broadcastTruncate(%q, 50) = %q, want %q", input, got, input)
+	}
+}
+
+func TestBroadcastTruncate_ExactlyAtLimit(t *testing.T) {
+	input := "exactly fifty char"
+	got := broadcastTruncate(input, 18)
+	if got != input {
+		t.Errorf("broadcastTruncate(%q, 18) = %q, want %q", input, got, input)
+	}
+}
+
+func TestBroadcastTruncate_OverLimit_TruncatesAndAddsEllipsis(t *testing.T) {
+	// 150 ASCII chars → over 120 rune limit → truncate to 120 + ellipsis
+	input := strings.Repeat("x", 150)
+	got := broadcastTruncate(input, 120)
+	if len([]rune(got)) != 121 { // 120 + 1 ellipsis rune
+		t.Errorf("len(broadcastTruncate) = %d, want 121 (120 + ellipsis)", len([]rune(got)))
+	}
+	if got[:len(got)-len("…")] != strings.Repeat("x", 120) {
+		t.Errorf("broadcastTruncate did not truncate correctly")
+	}
+}
+
+func TestBroadcastTruncate_UnicodeChars_TreatsAsRunes(t *testing.T) {
+	// Each emoji is 1 rune but multiple bytes. 50 emojis > 30 limit.
+	input := strings.Repeat("🎉", 50)
+	got := broadcastTruncate(input, 30)
+	if len([]rune(got)) != 31 { // 30 + ellipsis
+		t.Errorf("len(broadcastTruncate with emoji) = %d, want 31", len([]rune(got)))
+	}
+}
+
+func TestBroadcastTruncate_ZeroLimit_ReturnsEllipsis(t *testing.T) {
+	got := broadcastTruncate("hello", 0)
+	if got != "…" {
+		t.Errorf("broadcastTruncate with max=0 = %q, want …", got)
+	}
+}

workspace/tests/test_a2a_tools_messaging.py

@@ -15,15 +15,10 @@ This file pins:
      ``a2a_tools`` at module-load time (the layered architecture: it
      depends on ``a2a_tools_rbac`` + ``a2a_client`` + ``platform_auth``,
      never the kitchen-sink module).
-  3. **Behavioral tests** — tool_broadcast_message, _upload_chat_files,
-     and tool_send_message_to_user error paths not covered by the
-     impl-level test suite.
 """
 from __future__ import annotations
 
-import json
 import sys
-from unittest.mock import AsyncMock, patch
 
 import pytest
 
@@ -95,328 +90,3 @@ class TestImportContract:
         assert hasattr(a2a_tools, "tool_get_workspace_info")
         assert hasattr(a2a_tools, "tool_chat_history")
         assert hasattr(a2a_tools, "_upload_chat_files")
-
-
-# ---------------------------------------------------------------------------
-# Helpers shared by behavioral tests below
-# ---------------------------------------------------------------------------
-
-def _make_mock_client(*, post_resp=None, post_exc=None):
-    """Return a mock AsyncClient that behaves as an async context manager."""
-    mc = AsyncMock()
-    mc.__aenter__ = AsyncMock(return_value=mc)
-    mc.__aexit__ = AsyncMock(return_value=False)
-    if post_exc is not None:
-        mc.post = AsyncMock(side_effect=post_exc)
-    else:
-        mc.post = AsyncMock(return_value=post_resp)
-    return mc
-
-
-def _resp(status_code, payload):
-    """Build a fake httpx.Response with the given status and JSON body."""
-    response = AsyncMock()
-    response.status_code = status_code
-    response.json = lambda: payload
-    response.text = json.dumps(payload)
-    return response
-
-
-# ---------------------------------------------------------------------------
-# tool_broadcast_message — behavioral tests (not covered by test_a2a_tools_impl)
-# ---------------------------------------------------------------------------
-
-class TestToolBroadcastMessage:
-
-    async def test_empty_message_returns_error(self):
-        """Empty string returns an error without any HTTP call."""
-        import a2a_tools_messaging
-        result = await a2a_tools_messaging.tool_broadcast_message("")
-        assert "Error" in result
-        assert "required" in result
-
-    async def test_success_200_returns_delivered_count(self):
-        """200 with delivered count returns the count."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(200, {"delivered": 3}))
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("All hands meeting at 3pm")
-        assert "3" in result
-        assert "workspace" in result
-
-    async def test_success_200_missing_delivered_key_defaults_to_zero(self):
-        """200 with no delivered key doesn't crash — formats as '?'."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(200, {}))
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("ping")
-        assert "?" in result
-
-    async def test_403_returns_broadcast_disabled_error(self):
-        """403 with hint returns the hint text."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(403, {"hint": "Enable broadcast in workspace settings."}))
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
-        assert "403" not in result  # error class handles 403 specially
-        assert "not enabled" in result.lower()
-        assert "Enable broadcast" in result
-
-    async def test_403_without_hint_returns_generic_disabled_message(self):
-        """403 without a hint returns a generic disabled message."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(403, {}))
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
-        assert "not enabled" in result.lower()
-
-    async def test_403_malformed_json_returns_disabled_without_hint(self):
-        """403 where .json() raises still returns the disabled message."""
-        import a2a_tools_messaging
-        response = _resp(403, {})
-        response.json = lambda: (_ for _ in ()).throw(ValueError("boom"))
-        mc = _make_mock_client(post_resp=response)
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
-        assert "not enabled" in result.lower()
-
-    async def test_non_200_non_403_returns_status_code_error(self):
-        """Any other non-2xx status returns a generic error with the code."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(500, {"error": "internal error"}))
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
-        assert "500" in result
-        assert "Error" in result
-
-    async def test_connection_error_returns_error_with_exception_message(self):
-        """Network failure returns the exception text."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_exc=ConnectionError("connection refused"))
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
-        assert "Error sending broadcast" in result
-        assert "connection refused" in result
-
-
-# ---------------------------------------------------------------------------
-# _upload_chat_files — behavioral tests
-# ---------------------------------------------------------------------------
-
-class TestUploadChatFiles:
-    """Tests for the internal _upload_chat_files helper (lines 39-101)."""
-
-    async def test_empty_paths_returns_empty_and_none(self):
-        """Empty list returns ([], None) — no HTTP call."""
-        import a2a_tools_messaging
-        mc = _make_mock_client()
-        result = await a2a_tools_messaging._upload_chat_files(mc, [])
-        assert result == ([], None)
-
-    async def test_invalid_path_type_returns_error(self):
-        """Non-string path type returns an error without HTTP call."""
-        import a2a_tools_messaging
-        mc = _make_mock_client()
-        result = await a2a_tools_messaging._upload_chat_files(mc, [None])
-        assert result[1] is not None
-        assert "invalid" in result[1].lower()
-
-    async def test_empty_string_path_returns_error(self):
-        """Empty-string path returns an error without HTTP call."""
-        import a2a_tools_messaging
-        mc = _make_mock_client()
-        result = await a2a_tools_messaging._upload_chat_files(mc, [""])
-        assert result[1] is not None
-        assert "invalid" in result[1].lower()
-
-    async def test_nonexistent_path_returns_not_found_error(self):
-        """Path that doesn't exist on disk returns an error without HTTP call."""
-        import a2a_tools_messaging
-        mc = _make_mock_client()
-        result = await a2a_tools_messaging._upload_chat_files(
-            mc, ["/no/such/file/anywhere.txt"],
-        )
-        assert result[1] is not None
-        assert "not found" in result[1].lower()
-
-    async def test_read_error_returns_read_error_message(self, tmp_path):
-        """OSError on file read returns the OS error text."""
-        import a2a_tools_messaging
-        mc = _make_mock_client()
-
-        # Create a file, then remove its parent to trigger OSError on open.
-        f = tmp_path / "gone.txt"
-        f.write_text("stub")
-        f.chmod(0o000)  # remove read permission — OSError on open
-
-        try:
-            result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-            assert result[1] is not None
-            assert "Error reading" in result[1]
-        finally:
-            # Restore permissions so the temp dir cleanup can delete the file.
-            f.chmod(0o644)
-
-    async def test_upload_connection_error_returns_error(self, tmp_path):
-        """Connection failure returns the exception text."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_exc=OSError("no such host"))
-        f = tmp_path / "f.txt"
-        f.write_text("content")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[1] is not None
-        assert "Error uploading attachments" in result[1]
-        assert "no such host" in result[1]
-
-    async def test_upload_non_200_returns_status_code_error(self, tmp_path):
-        """Non-200 upload response returns error with status code."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(502, {"error": "bad gateway"}))
-        f = tmp_path / "f.txt"
-        f.write_text("content")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[1] is not None
-        assert "502" in result[1]
-
-    async def test_upload_invalid_json_returns_parse_error(self, tmp_path):
-        """Non-JSON response returns a parse error."""
-        import a2a_tools_messaging
-        response = _resp(200, {})
-        response.json = lambda: (_ for _ in ()).throw(ValueError("not json"))
-        response.text = "not json at all"
-        mc = _make_mock_client(post_resp=response)
-        f = tmp_path / "f.txt"
-        f.write_text("content")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[1] is not None
-        assert "Error parsing upload response" in result[1]
-
-    async def test_upload_missing_files_key_returns_invalid_error(self, tmp_path):
-        """200 with no 'files' key returns an error."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(200, {}))
-        f = tmp_path / "f.txt"
-        f.write_text("content")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[1] is not None
-        # Code path: body.get("files") returns [] (key absent), 0 != 1 → error.
-        assert "0" in result[1] and "1" in result[1]
-
-    async def test_upload_file_count_mismatch_returns_error(self, tmp_path):
-        """200 with wrong number of returned files returns an error."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(200, {"files": []}))
-        f1 = tmp_path / "a.txt"
-        f2 = tmp_path / "b.txt"
-        f1.write_text("a")
-        f2.write_text("b")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f1), str(f2)])
-        assert result[1] is not None
-        assert "0" in result[1]
-        assert "2" in result[1]
-
-    async def test_upload_success_returns_attachments_and_none(self, tmp_path):
-        """200 with the correct number of files returns the metadata list."""
-        import a2a_tools_messaging
-        expected = [{
-            "uri": "workspace:/workspace/.molecule/chat-uploads/test.txt",
-            "name": "test.txt",
-            "mimeType": "text/plain",
-            "size": 10,
-        }]
-        mc = _make_mock_client(post_resp=_resp(200, {"files": expected}))
-        f = tmp_path / "test.txt"
-        f.write_text("hello world")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[0] == expected
-        assert result[1] is None
-
-    async def test_mime_type_guessed_from_filename(self, tmp_path):
-        """mimetype is sniffable from a .pdf extension."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(200, {
-            "files": [{"uri": "x", "name": "report.pdf", "mimeType": "application/pdf", "size": 100}],
-        }))
-        f = tmp_path / "report.pdf"
-        f.write_text("stub")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[1] is None  # success
-        # Verify the POST was made with a multipart file.
-        call_args = mc.post.await_args
-        files_arg = call_args.kwargs.get("files")
-        assert files_arg is not None
-        assert any("report.pdf" in str(item) for item in files_arg)
-
-    async def test_unknown_extension_defaults_to_octet_stream(self, tmp_path):
-        """File with no extension gets application/octet-stream."""
-        import a2a_tools_messaging
-        mc = _make_mock_client(post_resp=_resp(200, {
-            "files": [{"uri": "x", "name": "blob", "mimeType": "application/octet-stream", "size": 5}],
-        }))
-        f = tmp_path / "blob"  # no extension
-        f.write_text("hello")
-        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
-        assert result[1] is None  # success
-
-
-# ---------------------------------------------------------------------------
-# tool_send_message_to_user — additional error paths (beyond test_a2a_tools_impl)
-# ---------------------------------------------------------------------------
-
-class TestToolSendMessageToUserMessaging:
-    """Error paths in tool_send_message_to_user not covered in test_a2a_tools_impl."""
-
-    async def test_upload_failure_prevents_notify_call(self, tmp_path):
-        """When _upload_chat_files returns an error, notify is never called."""
-        import a2a_tools_messaging
-        mc = _make_mock_client()
-        f = tmp_path / "gone.txt"
-        f.write_text("x")
-        f.chmod(0o000)
-        try:
-            with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-                result = await a2a_tools_messaging.tool_send_message_to_user(
-                    "Hi", attachments=[str(f)],
-                )
-            assert "Error" in result
-            # Permission-denied or "not found" — both halt before HTTP.
-            assert "permission denied" in result.lower() or "not found" in result.lower()
-            assert mc.post.await_count == 0
-        finally:
-            f.chmod(0o644)
-
-    async def test_403_talk_to_user_disabled_returns_detailed_error(self):
-        """403 with 'talk_to_user_disabled' returns the full error message."""
-        import a2a_tools_messaging
-        response = _resp(403, {
-            "error": "talk_to_user_disabled",
-            "hint": "Enable in workspace settings.",
-        })
-        mc = _make_mock_client(post_resp=response)
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_send_message_to_user("Hi")
-        assert "not allowed" in result
-        assert "talk_to_user is disabled" in result
-        assert "Enable in workspace settings" in result
-
-    async def test_403_talk_to_user_disabled_without_hint(self):
-        """403 with 'talk_to_user_disabled' but no hint is still readable."""
-        import a2a_tools_messaging
-        response = _resp(403, {"error": "talk_to_user_disabled"})
-        mc = _make_mock_client(post_resp=response)
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_send_message_to_user("Hi")
-        assert "not allowed" in result
-        assert "talk_to_user is disabled" in result
-
-    async def test_403_malformed_json_does_not_crash(self):
-        """403 where .json() raises still returns a sensible error."""
-        import a2a_tools_messaging
-        response = _resp(403, {})
-        response.json = lambda: (_ for _ in ()).throw(ValueError("boom"))
-        mc = _make_mock_client(post_resp=response)
-        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
-            result = await a2a_tools_messaging.tool_send_message_to_user("Hi")
-        # Falls through to the generic status code error.
-        assert "403" in result
-        assert "Error" in result