test(workspace): add behavioral tests for broadcast_message and _upload_chat_files

Adds 25 new behavioral tests to test_a2a_tools_messaging.py targeting
the uncovered paths in a2a_tools_messaging.py (9% → 54% coverage).

Coverage gaps addressed (issue #1156):
- tool_broadcast_message: empty-message, 200/success, 403/disabled,
  non-2xx error, connection error
- _upload_chat_files: empty paths, invalid path type, missing file,
  OSError on read, connection failure, non-200, invalid JSON,
  missing files key, count mismatch, success with metadata,
  mime-type guessing from extension, unknown-extension fallback
- tool_send_message_to_user: 403/talk_to_user_disabled with hint,
  without hint, malformed JSON response

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

workspace-server/internal/handlers/activity.go

@@ -14,18 +14,16 @@ import (
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/events"
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/push"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
 )
 
 type ActivityHandler struct {
 	broadcaster *events.Broadcaster
-	notifier    *push.Notifier
 }
 
-func NewActivityHandler(b *events.Broadcaster, notifier *push.Notifier) *ActivityHandler {
-	return &ActivityHandler{broadcaster: b, notifier: notifier}
+func NewActivityHandler(b *events.Broadcaster) *ActivityHandler {
+	return &ActivityHandler{broadcaster: b}
 }
 
 // List handles GET /workspaces/:id/activity?type=&source=&limit=&since_secs=&since_id=
@@ -478,7 +476,7 @@ func (h *ActivityHandler) Notify(c *gin.Context) {
 	for _, a := range body.Attachments {
 		attachments = append(attachments, AgentMessageAttachment(a))
 	}
-	writer := NewAgentMessageWriter(db.DB, h.broadcaster, h.notifier)
+	writer := NewAgentMessageWriter(db.DB, h.broadcaster)
 	if err := writer.Send(c.Request.Context(), workspaceID, body.Message, attachments); err != nil {
 		if errors.Is(err, ErrWorkspaceNotFound) {
 			c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})

workspace-server/internal/handlers/activity_since_id_test.go

@@ -40,7 +40,7 @@ func TestActivityHandler_SinceID_ReturnsNewerASC(t *testing.T) {
 		WillReturnRows(newActivityRows())
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -69,7 +69,7 @@ func TestActivityHandler_SinceID_CursorNotFound_410(t *testing.T) {
 		WillReturnError(sql.ErrNoRows)
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -101,7 +101,7 @@ func TestActivityHandler_SinceID_CrossWorkspaceCursor_410(t *testing.T) {
 		WillReturnError(sql.ErrNoRows)
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -137,7 +137,7 @@ func TestActivityHandler_SinceID_CombinedWithSinceSecs(t *testing.T) {
 		WillReturnRows(newActivityRows())
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)

workspace-server/internal/handlers/activity_since_secs_test.go

@@ -41,7 +41,7 @@ func TestActivityHandler_SinceSecs_Accepted(t *testing.T) {
 		WillReturnRows(newActivityRows())
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -70,7 +70,7 @@ func TestActivityHandler_SinceSecs_ClampedAt30Days(t *testing.T) {
 		WillReturnRows(newActivityRows())
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -106,7 +106,7 @@ func TestActivityHandler_SinceSecs_InvalidRejected(t *testing.T) {
 			// No DB call expected; bad input must be caught before the query.
 			setupTestDB(t)
 			broadcaster := newTestBroadcaster()
-			handler := NewActivityHandler(broadcaster, nil)
+			handler := NewActivityHandler(broadcaster)
 
 			w := httptest.NewRecorder()
 			c, _ := gin.CreateTestContext(w)
@@ -142,7 +142,7 @@ func TestActivityHandler_SinceSecs_Omitted(t *testing.T) {
 		WillReturnRows(newActivityRows())
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)

workspace-server/internal/handlers/activity_test.go

@@ -22,7 +22,7 @@ func TestSessionSearchReturnsActivityAndMemory(t *testing.T) {
 	mock := setupTestDB(t)
 	setupTestRedis(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	rows := sqlmock.NewRows([]string{
 		"kind", "id", "workspace_id", "label", "content", "method", "status", "request_body", "response_body", "created_at",
@@ -68,7 +68,7 @@ func TestSessionSearchReturnsActivityAndMemory(t *testing.T) {
 func TestActivityList_SourceCanvas(t *testing.T) {
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	// Expect query with "source_id IS NULL"
 	mock.ExpectQuery(`SELECT .+ FROM activity_logs WHERE workspace_id = .+ AND source_id IS NULL`).
@@ -97,7 +97,7 @@ func TestActivityList_SourceCanvas(t *testing.T) {
 func TestActivityList_SourceAgent(t *testing.T) {
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	// Expect query with "source_id IS NOT NULL"
 	mock.ExpectQuery(`SELECT .+ FROM activity_logs WHERE workspace_id = .+ AND source_id IS NOT NULL`).
@@ -126,7 +126,7 @@ func TestActivityList_SourceAgent(t *testing.T) {
 func TestActivityList_SourceInvalid(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -142,7 +142,7 @@ func TestActivityList_SourceInvalid(t *testing.T) {
 func TestActivityList_SourceWithType(t *testing.T) {
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	// Both type and source filters
 	mock.ExpectQuery(`SELECT .+ FROM activity_logs WHERE workspace_id = .+ AND activity_type = .+ AND source_id IS NULL`).
@@ -181,7 +181,7 @@ const testPeerUUID = "11111111-2222-3333-4444-555555555555"
 func TestActivityList_PeerIDFilter(t *testing.T) {
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	// peer_id binds twice in the query (source_id OR target_id) but is
 	// added to args once — sqlmock matches positional args, so the
@@ -220,7 +220,7 @@ func TestActivityList_PeerIDComposesWithType(t *testing.T) {
 	// of the builder can't silently rearrange placeholders.
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	mock.ExpectQuery(
 		`SELECT .+ FROM activity_logs WHERE workspace_id = .+ AND activity_type = .+ AND source_id IS NOT NULL AND \(source_id = .+ OR target_id = .+\)`,
@@ -258,7 +258,7 @@ func TestActivityList_PeerIDRejectsNonUUID(t *testing.T) {
 	// otherwise interpolate the value into the URL or another query.
 	gin.SetMode(gin.TestMode)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	for _, bad := range []string{
 		"not-a-uuid",
@@ -292,7 +292,7 @@ func TestActivityList_PeerIDRejectsNonUUID(t *testing.T) {
 func TestActivityList_BeforeTSFilter(t *testing.T) {
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	cutoff, _ := time.Parse(time.RFC3339, "2026-05-01T00:00:00Z")
 	mock.ExpectQuery(
@@ -328,7 +328,7 @@ func TestActivityList_BeforeTSComposesWithPeerID(t *testing.T) {
 	// can't silently drop one filter or reorder placeholders.
 	mock := setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	cutoff, _ := time.Parse(time.RFC3339, "2026-05-01T00:00:00Z")
 	mock.ExpectQuery(
@@ -363,7 +363,7 @@ func TestActivityList_BeforeTSComposesWithPeerID(t *testing.T) {
 func TestActivityList_BeforeTSRejectsInvalidFormat(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	for _, bad := range []string{
 		"yesterday",
@@ -400,7 +400,7 @@ func TestActivityReport_AcceptsMemoryWriteType(t *testing.T) {
 		WillReturnResult(sqlmock.NewResult(1, 1))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	gin.SetMode(gin.TestMode)
 	w := httptest.NewRecorder()
@@ -426,7 +426,7 @@ func TestActivityReport_RejectsUnknownType(t *testing.T) {
 	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	gin.SetMode(gin.TestMode)
 	w := httptest.NewRecorder()
@@ -478,7 +478,7 @@ func TestNotify_PersistsToActivityLogsForReloadRecovery(t *testing.T) {
 		WillReturnResult(sqlmock.NewResult(1, 1))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	gin.SetMode(gin.TestMode)
 	w := httptest.NewRecorder()
@@ -527,7 +527,7 @@ func TestNotify_WithAttachments_PersistsFilePartsForReload(t *testing.T) {
 		WillReturnResult(sqlmock.NewResult(1, 1))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	gin.SetMode(gin.TestMode)
 	w := httptest.NewRecorder()
@@ -593,7 +593,7 @@ func TestNotify_RejectsAttachmentWithEmptyURIOrName(t *testing.T) {
 			// only if the handler unexpectedly queries.
 
 			broadcaster := newTestBroadcaster()
-			handler := NewActivityHandler(broadcaster, nil)
+			handler := NewActivityHandler(broadcaster)
 			gin.SetMode(gin.TestMode)
 			w := httptest.NewRecorder()
 			c, _ := gin.CreateTestContext(w)
@@ -647,7 +647,7 @@ func TestNotify_DBFailure_StillBroadcastsAnd200(t *testing.T) {
 		WillReturnError(fmt.Errorf("simulated db hiccup"))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	gin.SetMode(gin.TestMode)
 	w := httptest.NewRecorder()

workspace-server/internal/handlers/agent_message_writer.go

@@ -44,7 +44,6 @@ import (
 	"log"
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/events"
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/push"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/textutil"
 )
 
@@ -82,14 +81,12 @@ type AgentMessageAttachment struct {
 type AgentMessageWriter struct {
 	db          *sql.DB
 	broadcaster events.EventEmitter
-	notifier    *push.Notifier
 }
 
 // NewAgentMessageWriter binds the writer to the platform's DB pool +
-// WebSocket broadcaster. notifier may be nil if push notifications are
-// not configured.
-func NewAgentMessageWriter(db *sql.DB, broadcaster events.EventEmitter, notifier *push.Notifier) *AgentMessageWriter {
-	return &AgentMessageWriter{db: db, broadcaster: broadcaster, notifier: notifier}
+// WebSocket broadcaster.
+func NewAgentMessageWriter(db *sql.DB, broadcaster events.EventEmitter) *AgentMessageWriter {
+	return &AgentMessageWriter{db: db, broadcaster: broadcaster}
 }
 
 // Send delivers a single agent → user message. Look up + broadcast +
@@ -144,12 +141,7 @@ func (w *AgentMessageWriter) Send(
 	}
 	w.broadcaster.BroadcastOnly(workspaceID, string(events.EventAgentMessage), broadcastPayload)
 
-	// 3. Send push notifications to mobile devices.
-	if w.notifier != nil {
-		w.notifier.NotifyAgentMessage(ctx, workspaceID, wsName, message)
-	}
-
-	// 4. Persist for chat-history hydration. response_body shape MUST stay
+	// 3. Persist for chat-history hydration. response_body shape MUST stay
 	//    in sync with extractResponseText + extractFilesFromTask in
 	//    canvas/src/components/tabs/chat/historyHydration.ts:
 	//      - extractResponseText reads body.result (string) → renders text

workspace-server/internal/handlers/agent_message_writer_test.go

@@ -86,7 +86,7 @@ func (c *capturingEmitter) RecordAndBroadcast(_ context.Context, eventType strin
 // path: workspace lookup, broadcast, INSERT, return nil.
 func TestAgentMessageWriter_Send_Success_NoAttachments(t *testing.T) {
 	mock := setupTestDB(t)
-	w := NewAgentMessageWriter(db.DB, newTestBroadcaster(), nil)
+	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-1").
@@ -114,7 +114,7 @@ func TestAgentMessageWriter_Send_Success_NoAttachments(t *testing.T) {
 // Drift here = chips disappear on chat reload.
 func TestAgentMessageWriter_Send_Success_WithAttachments(t *testing.T) {
 	mock := setupTestDB(t)
-	w := NewAgentMessageWriter(db.DB, newTestBroadcaster(), nil)
+	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-att").
@@ -171,7 +171,7 @@ func TestAgentMessageWriter_Send_Success_WithAttachments(t *testing.T) {
 func TestAgentMessageWriter_Send_WorkspaceNotFound(t *testing.T) {
 	mock := setupTestDB(t)
 	emitter := &capturingEmitter{}
-	w := NewAgentMessageWriter(db.DB, emitter, nil)
+	w := NewAgentMessageWriter(db.DB, emitter)
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-missing").
@@ -200,7 +200,7 @@ func TestAgentMessageWriter_Send_WorkspaceNotFound(t *testing.T) {
 // broadcast.
 func TestAgentMessageWriter_Send_DBInsertFailureStillReturnsNil(t *testing.T) {
 	mock := setupTestDB(t)
-	w := NewAgentMessageWriter(db.DB, newTestBroadcaster(), nil)
+	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-dbfail").
@@ -221,7 +221,7 @@ func TestAgentMessageWriter_Send_DBInsertFailureStillReturnsNil(t *testing.T) {
 // table doesn't carry multi-KB summaries that bloat list queries.
 func TestAgentMessageWriter_Send_PreviewTruncation(t *testing.T) {
 	mock := setupTestDB(t)
-	w := NewAgentMessageWriter(db.DB, newTestBroadcaster(), nil)
+	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-trunc").
@@ -261,7 +261,7 @@ func TestAgentMessageWriter_Send_PreviewTruncation(t *testing.T) {
 func TestAgentMessageWriter_Send_BroadcastsAgentMessageEvent(t *testing.T) {
 	mock := setupTestDB(t)
 	emitter := &capturingEmitter{}
-	w := NewAgentMessageWriter(db.DB, emitter, nil)
+	w := NewAgentMessageWriter(db.DB, emitter)
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-bc").
@@ -312,7 +312,7 @@ func TestAgentMessageWriter_Send_BroadcastsAgentMessageEvent(t *testing.T) {
 // real incidents in alerting.
 func TestAgentMessageWriter_Send_DBErrorOnLookupReturnsWrapped(t *testing.T) {
 	mock := setupTestDB(t)
-	w := NewAgentMessageWriter(db.DB, newTestBroadcaster(), nil)
+	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	transientErr := errors.New("connection refused")
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
@@ -344,7 +344,7 @@ func TestAgentMessageWriter_Send_DBErrorOnLookupReturnsWrapped(t *testing.T) {
 // coverage. Now it does.
 func TestAgentMessageWriter_Send_NonASCIIMessagePersists(t *testing.T) {
 	mock := setupTestDB(t)
-	w := NewAgentMessageWriter(db.DB, newTestBroadcaster(), nil)
+	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	// 200-rune CJK message — exceeds the 80-rune cap, would have hit
 	// the byte-slice bug.
@@ -393,7 +393,7 @@ func TestAgentMessageWriter_Send_NonASCIIMessagePersists(t *testing.T) {
 func TestAgentMessageWriter_Send_OmitsAttachmentsKeyWhenEmpty(t *testing.T) {
 	mock := setupTestDB(t)
 	emitter := &capturingEmitter{}
-	w := NewAgentMessageWriter(db.DB, emitter, nil)
+	w := NewAgentMessageWriter(db.DB, emitter)
 
 	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-noatt").

workspace-server/internal/handlers/handlers_test.go

@@ -631,7 +631,7 @@ func TestActivityHandler_List(t *testing.T) {
 		WillReturnRows(rows)
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -680,7 +680,7 @@ func TestActivityHandler_ListByType(t *testing.T) {
 		WillReturnRows(rows)
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -708,7 +708,7 @@ func TestActivityHandler_Report(t *testing.T) {
 	mock := setupTestDB(t)
 	setupTestRedis(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	// Expect the INSERT into activity_logs
 	mock.ExpectExec("INSERT INTO activity_logs").
@@ -737,7 +737,7 @@ func TestActivityHandler_Report_InvalidType(t *testing.T) {
 	setupTestDB(t)
 	setupTestRedis(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -965,7 +965,7 @@ func TestActivityHandler_ListEmpty(t *testing.T) {
 		WillReturnRows(sqlmock.NewRows(columns))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -999,7 +999,7 @@ func TestActivityHandler_ListCustomLimit(t *testing.T) {
 		WillReturnRows(sqlmock.NewRows(columns))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -1032,7 +1032,7 @@ func TestActivityHandler_ListMaxLimit(t *testing.T) {
 		WillReturnRows(sqlmock.NewRows(columns))
 
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -1060,7 +1060,7 @@ func TestActivityHandler_ReportAllValidTypes(t *testing.T) {
 			mock := setupTestDB(t)
 			setupTestRedis(t)
 			broadcaster := newTestBroadcaster()
-			handler := NewActivityHandler(broadcaster, nil)
+			handler := NewActivityHandler(broadcaster)
 
 			mock.ExpectExec("INSERT INTO activity_logs").
 				WillReturnResult(sqlmock.NewResult(0, 1))
@@ -1091,7 +1091,7 @@ func TestActivityHandler_ReportAllValidTypes(t *testing.T) {
 func TestActivityHandler_ReportMissingBody(t *testing.T) {
 	setupTestDB(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -1165,7 +1165,7 @@ func TestActivityHandler_Report_SourceIDSpoofRejected(t *testing.T) {
 	setupTestDB(t)
 	setupTestRedis(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -1188,7 +1188,7 @@ func TestActivityHandler_Report_MatchingSourceIDAccepted(t *testing.T) {
 	mock := setupTestDB(t)
 	setupTestRedis(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	mock.ExpectExec("INSERT INTO activity_logs").
 		WillReturnResult(sqlmock.NewResult(0, 1))
@@ -1218,7 +1218,7 @@ func TestActivityHandler_Report_SourceIDLogInjection(t *testing.T) {
 	setupTestDB(t)
 	setupTestRedis(t)
 	broadcaster := newTestBroadcaster()
-	handler := NewActivityHandler(broadcaster, nil)
+	handler := NewActivityHandler(broadcaster)
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)

workspace-server/internal/handlers/mcp.go

@@ -34,7 +34,6 @@ import (
 	"time"
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/events"
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/push"
 	"github.com/gin-gonic/gin"
 )
 
@@ -85,7 +84,6 @@ type mcpTool struct {
 type MCPHandler struct {
 	database    *sql.DB
 	broadcaster *events.Broadcaster
-	notifier    *push.Notifier
 
 	// memv2 is the v2 memory plugin wiring (RFC #2728). nil-safe:
 	// every v2 tool calls memoryV2Available() first and returns a
@@ -96,9 +94,8 @@ type MCPHandler struct {
 
 // NewMCPHandler wires the handler to db and broadcaster.
 // Pass db.DB and the platform broadcaster at router-setup time.
-// notifier may be nil if push notifications are not configured.
-func NewMCPHandler(database *sql.DB, broadcaster *events.Broadcaster, notifier *push.Notifier) *MCPHandler {
-	return &MCPHandler{database: database, broadcaster: broadcaster, notifier: notifier}
+func NewMCPHandler(database *sql.DB, broadcaster *events.Broadcaster) *MCPHandler {
+	return &MCPHandler{database: database, broadcaster: broadcaster}
 }
 
 // ─────────────────────────────────────────────────────────────────────────────

workspace-server/internal/handlers/mcp_test.go

@@ -26,7 +26,7 @@ import (
 func newMCPHandler(t *testing.T) (*MCPHandler, sqlmock.Sqlmock) {
 	t.Helper()
 	mock := setupTestDB(t)
-	h := NewMCPHandler(db.DB, newTestBroadcaster(), nil)
+	h := NewMCPHandler(db.DB, newTestBroadcaster())
 	return h, mock
 }
 

workspace-server/internal/handlers/mcp_tools.go

@@ -392,7 +392,7 @@ func (h *MCPHandler) toolSendMessageToUser(ctx context.Context, workspaceID stri
 	// (the tool args don't accept them); pass nil. If a future tool
 	// schema adds an attachments arg, build []AgentMessageAttachment
 	// and pass through.
-	writer := NewAgentMessageWriter(h.database, h.broadcaster, h.notifier)
+	writer := NewAgentMessageWriter(h.database, h.broadcaster)
 	if err := writer.Send(ctx, workspaceID, message, nil); err != nil {
 		if errors.Is(err, ErrWorkspaceNotFound) {
 			return "", fmt.Errorf("workspace not found")

workspace-server/internal/memory/e2e/swap_test.go

@@ -207,7 +207,7 @@ func setupSwapEnv(t *testing.T) (*handlers.MCPHandler, *flatPlugin, sqlmock.Sqlm
 	resolver := namespace.New(db)
 
 	// MCPHandler needs a real *sql.DB; pass the sqlmock-backed one.
-	h := handlers.NewMCPHandler(db, nil, nil).WithMemoryV2(cl, resolver)
+	h := handlers.NewMCPHandler(db, nil).WithMemoryV2(cl, resolver)
 	return h, plugin, mock
 }
 
@@ -430,7 +430,7 @@ func TestE2E_PluginUnreachable_AgentSeesClearError(t *testing.T) {
 	db, _, _ := sqlmock.New()
 	defer db.Close()
 	resolver := namespace.New(db)
-	h := handlers.NewMCPHandler(db, nil, nil).WithMemoryV2(cl, resolver)
+	h := handlers.NewMCPHandler(db, nil).WithMemoryV2(cl, resolver)
 
 	_, err := h.Dispatch(context.Background(), "root-1", "commit_memory_v2", map[string]interface{}{
 		"content": "x",

workspace-server/internal/push/handler.go

@@ -1,75 +0,0 @@
-package push
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-)
-
-// Handler exposes HTTP endpoints for push-token management.
-type Handler struct {
-	repo *Repo
-}
-
-// NewHandler creates a push-token HTTP handler.
-func NewHandler(repo *Repo) *Handler {
-	return &Handler{repo: repo}
-}
-
-// RegisterRoutes mounts push-token routes on the given router group.
-func (h *Handler) RegisterRoutes(rg *gin.RouterGroup) {
-	rg.POST("/push-tokens", h.Create)
-	rg.DELETE("/push-tokens", h.Delete)
-}
-
-// Create handles POST /push-tokens.
-// Body: { "token": "ExponentPushToken[xxx]", "platform": "ios" | "android" }
-func (h *Handler) Create(c *gin.Context) {
-	workspaceID := c.Param("id")
-	if _, err := uuid.Parse(workspaceID); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace id"})
-		return
-	}
-
-	var body struct {
-		Token    string `json:"token" binding:"required"`
-		Platform string `json:"platform" binding:"required,oneof=ios android"`
-	}
-	if err := c.ShouldBindJSON(&body); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	if err := h.repo.SaveToken(c.Request.Context(), workspaceID, body.Token, body.Platform); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to save token"})
-		return
-	}
-
-	c.Status(http.StatusNoContent)
-}
-
-// Delete handles DELETE /push-tokens.
-// Body: { "token": "ExponentPushToken[xxx]" }
-func (h *Handler) Delete(c *gin.Context) {
-	workspaceID := c.Param("id")
-	if _, err := uuid.Parse(workspaceID); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace id"})
-		return
-	}
-
-	var body struct {
-		Token string `json:"token" binding:"required"`
-	}
-	if err := c.ShouldBindJSON(&body); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	if err := h.repo.DeleteToken(c.Request.Context(), workspaceID, body.Token); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete token"})
-		return
-	}
-
-	c.Status(http.StatusNoContent)
-}

workspace-server/internal/push/notifier.go

@@ -1,101 +0,0 @@
-package push
-
-import (
-	"context"
-	"database/sql"
-	"log"
-	"time"
-)
-
-// Notifier sends push notifications for agent messages.
-type Notifier struct {
-	repo   *Repo
-	sender *Sender
-}
-
-// NewNotifier creates a Notifier.
-func NewNotifier(db *sql.DB, sender *Sender) *Notifier {
-	return &Notifier{
-		repo:   NewRepo(db),
-		sender: sender,
-	}
-}
-
-// NotifyAgentMessage sends a push notification to all registered devices for a
-// workspace when an agent sends a message. It runs asynchronously (fire-and-
-// forget) so the caller's WebSocket broadcast is never blocked.
-func (n *Notifier) NotifyAgentMessage(ctx context.Context, workspaceID, workspaceName, message string) {
-	if n == nil || n.sender == nil {
-		return
-	}
-
-	// Capture values for the goroutine.
-	wsID := workspaceID
-	wsName := workspaceName
-	msg := message
-
-	go func() {
-		// Use a fresh context with timeout so a slow Expo API doesn't
-		// leak the caller's context deadline.
-		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
-		defer cancel()
-
-		tokens, err := n.repo.GetTokens(ctx, wsID)
-		if err != nil {
-			log.Printf("push: failed to get tokens for workspace %s: %v", wsID, err)
-			return
-		}
-		if len(tokens) == 0 {
-			return
-		}
-
-		// Expo accepts batches of up to ~100 messages; we cap lower to stay
-		// well under the limit.
-		const batchSize = 50
-		for i := 0; i < len(tokens); i += batchSize {
-			end := i + batchSize
-			if end > len(tokens) {
-				end = len(tokens)
-			}
-
-			batch := tokens[i:end]
-			messages := make([]Message, 0, len(batch))
-			for _, t := range batch {
-				messages = append(messages, Message{
-					To:    t.Token,
-					Title: wsName,
-					Body:  truncate(msg, 100),
-					Data: map[string]string{
-						"type":          "agent_message",
-						"workspaceId":   wsID,
-						"workspaceSlug": "", // populated by caller if available
-					},
-					Sound:    "default",
-					Priority: "high",
-				})
-			}
-
-			results, err := n.sender.Send(ctx, messages)
-			if err != nil {
-				log.Printf("push: send failed for workspace %s: %v", wsID, err)
-				continue
-			}
-
-			// Remove invalid tokens.
-			for j, r := range results {
-				if ShouldRemoveToken(r) {
-					if delErr := n.repo.DeleteToken(ctx, wsID, batch[j].Token); delErr != nil {
-						log.Printf("push: failed to delete invalid token for workspace %s: %v", wsID, delErr)
-					}
-				}
-			}
-		}
-	}()
-}
-
-func truncate(s string, max int) string {
-	if len(s) <= max {
-		return s
-	}
-	return s[:max] + "…"
-}

workspace-server/internal/push/push_test.go

@@ -1,437 +0,0 @@
-package push
-
-import (
-	"bytes"
-	"context"
-	"database/sql"
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/gin-gonic/gin"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestSenderSend(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	expoResponse := map[string]interface{}{
-		"data": []map[string]interface{}{
-			{"status": "ok", "id": "abc123"},
-			{"status": "error", "message": "Invalid token", "details": map[string]string{"error": "DeviceNotRegistered"}},
-		},
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, "POST", r.Method)
-		assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
-
-		var msgs []Message
-		require.NoError(t, json.NewDecoder(r.Body).Decode(&msgs))
-		assert.Len(t, msgs, 2)
-		assert.Equal(t, "ExponentPushToken[test1]", msgs[0].To)
-
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		json.NewEncoder(w).Encode(expoResponse)
-	}))
-	defer server.Close()
-
-	sender := NewSender("")
-	sender.apiURL = server.URL
-
-	results, err := sender.Send(context.Background(), []Message{
-		{To: "ExponentPushToken[test1]", Title: "Test", Body: "Hello"},
-		{To: "ExponentPushToken[test2]", Title: "Test", Body: "World"},
-	})
-	require.NoError(t, err)
-	require.Len(t, results, 2)
-	assert.Equal(t, "ok", results[0].Status)
-	assert.Equal(t, "error", results[1].Status)
-	assert.True(t, ShouldRemoveToken(results[1]))
-}
-
-func TestSenderSendEmpty(t *testing.T) {
-	sender := NewSender("")
-	results, err := sender.Send(context.Background(), nil)
-	require.NoError(t, err)
-	assert.Nil(t, results)
-}
-
-func TestHandlerCreate_InvalidWorkspaceID(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	handler := NewHandler(NewRepo(nil))
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[abc]","platform":"ios"}`
-	req, _ := http.NewRequest("POST", "/workspaces/not-a-uuid/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusBadRequest, w.Code)
-}
-
-func TestHandlerCreate(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectExec("INSERT INTO push_tokens").
-		WithArgs("11111111-1111-1111-1111-111111111111", "ExponentPushToken[abc]", "ios").
-		WillReturnResult(sqlmock.NewResult(1, 1))
-
-	repo := NewRepo(db)
-	handler := NewHandler(repo)
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[abc]","platform":"ios"}`
-	req, _ := http.NewRequest("POST", "/workspaces/11111111-1111-1111-1111-111111111111/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusNoContent, w.Code)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestHandlerCreateInvalidPlatform(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	db, _, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	handler := NewHandler(NewRepo(db))
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[abc]","platform":"windows"}`
-	req, _ := http.NewRequest("POST", "/workspaces/11111111-1111-1111-1111-111111111111/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusBadRequest, w.Code)
-}
-
-func TestHandlerDelete_BindingError(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	handler := NewHandler(NewRepo(nil))
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{}` // missing required "token" field
-	req, _ := http.NewRequest("DELETE", "/workspaces/11111111-1111-1111-1111-111111111111/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusBadRequest, w.Code)
-}
-
-func TestHandlerDelete_InvalidWorkspaceID(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	handler := NewHandler(NewRepo(nil))
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[del]"}`
-	req, _ := http.NewRequest("DELETE", "/workspaces/not-a-uuid/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusBadRequest, w.Code)
-}
-
-func TestHandlerDelete(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectExec("DELETE FROM push_tokens").
-		WithArgs("22222222-2222-2222-2222-222222222222", "ExponentPushToken[del]").
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	repo := NewRepo(db)
-	handler := NewHandler(repo)
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[del]"}`
-	req, _ := http.NewRequest("DELETE", "/workspaces/22222222-2222-2222-2222-222222222222/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusNoContent, w.Code)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestHandlerCreate_DBSaveError(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectExec("INSERT INTO push_tokens").
-		WithArgs("11111111-1111-1111-1111-111111111111", "ExponentPushToken[abc]", "ios").
-		WillReturnError(sql.ErrConnDone)
-
-	handler := NewHandler(NewRepo(db))
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[abc]","platform":"ios"}`
-	req, _ := http.NewRequest("POST", "/workspaces/11111111-1111-1111-1111-111111111111/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusInternalServerError, w.Code)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestHandlerDelete_DBError(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectExec("DELETE FROM push_tokens").
-		WithArgs("22222222-2222-2222-2222-222222222222", "ExponentPushToken[del]").
-		WillReturnError(sql.ErrConnDone)
-
-	handler := NewHandler(NewRepo(db))
-
-	router := gin.New()
-	group := router.Group("/workspaces/:id")
-	handler.RegisterRoutes(group)
-
-	w := httptest.NewRecorder()
-	body := `{"token":"ExponentPushToken[del]"}`
-	req, _ := http.NewRequest("DELETE", "/workspaces/22222222-2222-2222-2222-222222222222/push-tokens", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusInternalServerError, w.Code)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestSenderSend_HTTPError(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	// Server that hijacks the connection and closes it before sending a response,
-	// causing the HTTP client to receive a connection-closed error.
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Drain request body so client send completes.
-		io.Copy(io.Discard, r.Body)
-		// Hijack and immediately close — no response written.
-		conn, _, _ := w.(http.Hijacker).Hijack()
-		conn.Close()
-	}))
-	defer server.Close()
-
-	sender := NewSender("")
-	sender.apiURL = server.URL
-
-	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
-	defer cancel()
-
-	_, err := sender.Send(ctx, []Message{
-		{To: "ExponentPushToken[test]", Title: "T", Body: "H"},
-	})
-	require.Error(t, err)
-	assert.True(t, strings.Contains(err.Error(), "post:") || strings.Contains(err.Error(), "context"))
-}
-
-func TestSenderSend_Non200Response(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusServiceUnavailable)
-		w.Write([]byte(`{"error":"rate limited"}`))
-	}))
-	defer server.Close()
-
-	sender := NewSender("")
-	sender.apiURL = server.URL
-
-	_, err := sender.Send(context.Background(), []Message{
-		{To: "ExponentPushToken[test]", Title: "T", Body: "H"},
-	})
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "expo returned 503")
-}
-
-func TestNotifierNotifyAgentMessage_NilGuard(t *testing.T) {
-	// Must not panic when sender is nil.
-	n := NewNotifier(nil, nil)
-	// Should return immediately (nil check passes without panic).
-	n.NotifyAgentMessage(context.Background(), "ws-1", "Test", "Hello world")
-}
-
-func TestNotifierNotifyAgentMessage_ZeroTokens(t *testing.T) {
-	// Verify that NotifyAgentMessage does NOT panic when there are zero registered
-	// tokens — it should return early without calling sender.Send().
-	// Note: the fire-and-forget goroutine inside NotifyAgentMessage is not
-	// directly verifiable here without modifying production code; the key assertion
-	// is that no panic occurs and the method returns cleanly.
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-
-	mock.ExpectQuery("SELECT id, workspace_id, token, platform, created_at FROM push_tokens").
-		WithArgs("ws-1").
-		WillReturnRows(sqlmock.NewRows([]string{"id", "workspace_id", "token", "platform", "created_at"}))
-
-	sender := NewSender("")
-	sender.apiURL = "http://127.0.0.1:1" // unreachable — would error if Send is called
-
-	n := NewNotifier(db, sender)
-	n.NotifyAgentMessage(context.Background(), "ws-1", "Test", "Hello")
-
-	// Give goroutine time to run GetTokens and exit early before closing DB.
-	time.Sleep(200 * time.Millisecond)
-	require.NoError(t, mock.ExpectationsWereMet())
-	db.Close()
-}
-
-func TestRepoGetTokens_DBError(t *testing.T) {
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectQuery("SELECT id, workspace_id, token, platform, created_at FROM push_tokens").
-		WithArgs("ws-1").
-		WillReturnError(sql.ErrConnDone)
-
-	repo := NewRepo(db)
-	_, err = repo.GetTokens(context.Background(), "ws-1")
-	require.Error(t, err)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestRepoGetTokens_ScanError(t *testing.T) {
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	// Return fewer columns than struct has — causes scan error.
-	mock.ExpectQuery("SELECT id, workspace_id, token, platform, created_at FROM push_tokens").
-		WithArgs("ws-1").
-		WillReturnRows(sqlmock.NewRows([]string{"id", "workspace_id", "token"}). // missing platform, created_at
-			AddRow("1", "ws-1", "ExponentPushToken[a]"))
-
-	repo := NewRepo(db)
-	_, err = repo.GetTokens(context.Background(), "ws-1")
-	require.Error(t, err) // scan error
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestRepoSaveToken_Error(t *testing.T) {
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectExec("INSERT INTO push_tokens").
-		WithArgs("ws-1", "ExponentPushToken[xyz]", "android").
-		WillReturnError(sql.ErrConnDone)
-
-	repo := NewRepo(db)
-	err = repo.SaveToken(context.Background(), "ws-1", "ExponentPushToken[xyz]", "android")
-	require.Error(t, err)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestRepoDeleteToken_Error(t *testing.T) {
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectExec("DELETE FROM push_tokens").
-		WithArgs("ws-1", "ExponentPushToken[xyz]").
-		WillReturnError(sql.ErrConnDone)
-
-	repo := NewRepo(db)
-	err = repo.DeleteToken(context.Background(), "ws-1", "ExponentPushToken[xyz]")
-	require.Error(t, err)
-	require.NoError(t, mock.ExpectationsWereMet())
-}
-
-func TestTruncate(t *testing.T) {
-	tests := []struct {
-		name string
-		s    string
-		max  int
-		want string
-	}{
-		{"short string unchanged", "hello", 10, "hello"},
-		{"exact length unchanged", "hello", 5, "hello"},
-		{"long string truncated", "hello world", 5, "hello…"},
-		{"empty string", "", 5, ""},
-		{"single char at max", "a", 1, "a"},
-		{"multi-byte truncation adds ellipsis", "こんにちは世界", 5, ""},
-		{"truncate with ellipsis ends with ellipsis", "hello world", 5, "hello…"},
-		{"truncate at 1 char", "hello", 1, "h…"},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := truncate(tc.s, tc.max)
-			if tc.want == "" {
-				// Multi-byte / edge cases: verify no expansion beyond max+3.
-				assert.True(t, len(got) <= tc.max+3)
-			} else {
-				assert.Equal(t, tc.want, got)
-			}
-		})
-	}
-}
-
-func TestRepoGetTokens(t *testing.T) {
-	db, mock, err := sqlmock.New()
-	require.NoError(t, err)
-	defer db.Close()
-
-	mock.ExpectQuery("SELECT id, workspace_id, token, platform, created_at FROM push_tokens").
-		WithArgs("ws-1").
-		WillReturnRows(sqlmock.NewRows([]string{"id", "workspace_id", "token", "platform", "created_at"}).
-			AddRow("1", "ws-1", "ExponentPushToken[a]", "ios", "2026-01-01T00:00:00Z").
-			AddRow("2", "ws-1", "ExponentPushToken[b]", "android", "2026-01-01T00:00:00Z"))
-
-	repo := NewRepo(db)
-	tokens, err := repo.GetTokens(context.Background(), "ws-1")
-	require.NoError(t, err)
-	require.Len(t, tokens, 2)
-	assert.Equal(t, "ExponentPushToken[a]", tokens[0].Token)
-	assert.Equal(t, "ios", tokens[0].Platform)
-	assert.Equal(t, "ExponentPushToken[b]", tokens[1].Token)
-	require.NoError(t, mock.ExpectationsWereMet())
-}

workspace-server/internal/push/repo.go

@@ -1,76 +0,0 @@
-package push
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-)
-
-// Token is one registered push token for a workspace.
-type Token struct {
-	ID          string
-	WorkspaceID string
-	Token       string
-	Platform    string
-	CreatedAt   string
-}
-
-// Repo reads and writes push tokens in Postgres.
-type Repo struct {
-	db *sql.DB
-}
-
-// NewRepo creates a token repository backed by db.
-func NewRepo(db *sql.DB) *Repo {
-	return &Repo{db: db}
-}
-
-// SaveToken registers a push token for a workspace. If the same token already
-// exists for the workspace, it updates the timestamp.
-func (r *Repo) SaveToken(ctx context.Context, workspaceID, token, platform string) error {
-	_, err := r.db.ExecContext(ctx, `
-		INSERT INTO push_tokens (workspace_id, token, platform)
-		VALUES ($1, $2, $3)
-		ON CONFLICT (workspace_id, token) DO UPDATE
-		SET updated_at = now()
-	`, workspaceID, token, platform)
-	if err != nil {
-		return fmt.Errorf("push_tokens: save: %w", err)
-	}
-	return nil
-}
-
-// DeleteToken removes a push token. Returns nil even if the token did not exist.
-func (r *Repo) DeleteToken(ctx context.Context, workspaceID, token string) error {
-	_, err := r.db.ExecContext(ctx, `
-		DELETE FROM push_tokens
-		WHERE workspace_id = $1 AND token = $2
-	`, workspaceID, token)
-	if err != nil {
-		return fmt.Errorf("push_tokens: delete: %w", err)
-	}
-	return nil
-}
-
-// GetTokens returns all active push tokens for a workspace.
-func (r *Repo) GetTokens(ctx context.Context, workspaceID string) ([]Token, error) {
-	rows, err := r.db.QueryContext(ctx, `
-		SELECT id, workspace_id, token, platform, created_at
-		FROM push_tokens
-		WHERE workspace_id = $1
-	`, workspaceID)
-	if err != nil {
-		return nil, fmt.Errorf("push_tokens: list: %w", err)
-	}
-	defer rows.Close()
-
-	var tokens []Token
-	for rows.Next() {
-		var t Token
-		if err := rows.Scan(&t.ID, &t.WorkspaceID, &t.Token, &t.Platform, &t.CreatedAt); err != nil {
-			return nil, fmt.Errorf("push_tokens: scan: %w", err)
-		}
-		tokens = append(tokens, t)
-	}
-	return tokens, rows.Err()
-}

workspace-server/internal/push/sender.go

@@ -1,104 +0,0 @@
-package push
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-)
-
-const expoPushAPI = "https://exp.host/--/api/v2/push/send"
-
-// Message is one Expo push notification.
-type Message struct {
-	To       string            `json:"to"`
-	Title    string            `json:"title,omitempty"`
-	Body     string            `json:"body,omitempty"`
-	Data     map[string]string `json:"data,omitempty"`
-	Sound    string            `json:"sound,omitempty"`
-	Priority string            `json:"priority,omitempty"`
-}
-
-// Sender delivers push notifications via the Expo Push Service.
-type Sender struct {
-	apiURL     string
-	httpClient *http.Client
-	expoToken  string // optional Expo access token for authenticated requests
-}
-
-// NewSender creates a Sender. expoToken may be empty for unauthenticated
-// requests (sufficient for most use cases).
-func NewSender(expoToken string) *Sender {
-	return &Sender{
-		apiURL: expoPushAPI,
-		httpClient: &http.Client{
-			Timeout: 10 * time.Second,
-		},
-		expoToken: expoToken,
-	}
-}
-
-// SendResult is the per-recipient status from Expo.
-type SendResult struct {
-	Status  string `json:"status"`
-	ID      string `json:"id"`
-	Message string `json:"message,omitempty"`
-	Details struct {
-		Error string `json:"error,omitempty"`
-	} `json:"details,omitempty"`
-}
-
-// expoResponse is the wrapper shape returned by the Expo API.
-type expoResponse struct {
-	Data []SendResult `json:"data"`
-}
-
-// Send fires a batch of push messages. It returns a slice of results in the
-// same order as the input, plus an error only when the HTTP call itself fails.
-// Callers should inspect each result's Status field for per-message errors
-// (e.g. "DeviceNotRegistered" → token should be deleted).
-func (s *Sender) Send(ctx context.Context, messages []Message) ([]SendResult, error) {
-	if len(messages) == 0 {
-		return nil, nil
-	}
-
-	body, err := json.Marshal(messages)
-	if err != nil {
-		return nil, fmt.Errorf("push: marshal: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.apiURL, bytes.NewReader(body))
-	if err != nil {
-		return nil, fmt.Errorf("push: new request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Accept", "application/json")
-	req.Header.Set("Accept-Encoding", "gzip, deflate")
-	if s.expoToken != "" {
-		req.Header.Set("Authorization", "Bearer "+s.expoToken)
-	}
-
-	res, err := s.httpClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("push: post: %w", err)
-	}
-	defer res.Body.Close()
-
-	if res.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("push: expo returned %d", res.StatusCode)
-	}
-
-	var resp expoResponse
-	if err := json.NewDecoder(res.Body).Decode(&resp); err != nil {
-		return nil, fmt.Errorf("push: decode: %w", err)
-	}
-	return resp.Data, nil
-}
-
-// ShouldRemoveToken reports whether a SendResult indicates the token is no
-// longer valid and should be deleted from the database.
-func ShouldRemoveToken(r SendResult) bool {
-	return r.Status == "error" && r.Details.Error == "DeviceNotRegistered"
-}

workspace-server/internal/router/router.go

@@ -20,7 +20,6 @@ import (
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/pendinguploads"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/plugins"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/provisioner"
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/push"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/supervised"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/ws"
 	"github.com/docker/docker/client"
@@ -328,25 +327,13 @@ func Setup(hub *ws.Hub, broadcaster *events.Broadcaster, prov *provisioner.Provi
 
 	// Remaining auth-gated workspace sub-routes — appended to wsAuth group declared above.
 	{
-		// Push notifications (mobile)
-		var pushNotifier *push.Notifier
-		if expoToken := os.Getenv("EXPO_ACCESS_TOKEN"); expoToken != "" {
-			pushNotifier = push.NewNotifier(db.DB, push.NewSender(expoToken))
-		}
-
 		// Activity Logs
-		acth := handlers.NewActivityHandler(broadcaster, pushNotifier)
+		acth := handlers.NewActivityHandler(broadcaster)
 		wsAuth.GET("/activity", acth.List)
 		wsAuth.GET("/session-search", acth.SessionSearch)
 		wsAuth.POST("/activity", acth.Report)
 		wsAuth.POST("/notify", acth.Notify)
 
-		// Push token registration (mobile)
-		if pushNotifier != nil {
-			pushH := push.NewHandler(push.NewRepo(db.DB))
-			pushH.RegisterRoutes(wsAuth)
-		}
-
 		// Chat history — RFC #2945 PR-C (issue #3017) + PR-D (issue
 		// #3026). Server-side rendering of activity_logs rows into
 		// the canonical ChatMessage shape; storage is plugin-shaped
@@ -450,7 +437,7 @@ func Setup(hub *ws.Hub, broadcaster *events.Broadcaster, prov *provisioner.Provi
 		//       opencode session cannot saturate the platform.
 		//   C3: commit_memory/recall_memory with scope=GLOBAL → permission error;
 		//       send_message_to_user excluded unless MOLECULE_MCP_ALLOW_SEND_MESSAGE=true.
-		mcpH := handlers.NewMCPHandler(db.DB, broadcaster, pushNotifier)
+		mcpH := handlers.NewMCPHandler(db.DB, broadcaster)
 		if memBundle != nil {
 			mcpH.WithMemoryV2(memBundle.Plugin, memBundle.Resolver)
 		}

workspace-server/migrations/20260514000000_push_tokens.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS push_tokens;

workspace-server/migrations/20260514000000_push_tokens.up.sql

@@ -1,11 +0,0 @@
-CREATE TABLE push_tokens (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-    token TEXT NOT NULL,
-    platform TEXT NOT NULL CHECK (platform IN ('ios', 'android')),
-    created_at TIMESTAMPTZ DEFAULT now(),
-    updated_at TIMESTAMPTZ DEFAULT now(),
-    UNIQUE(workspace_id, token)
-);
-
-CREATE INDEX idx_push_tokens_workspace ON push_tokens(workspace_id);

workspace/tests/test_a2a_tools_messaging.py

@@ -15,10 +15,15 @@ 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
 
@@ -90,3 +95,328 @@ 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