[FEATURE] Display MCP server notifications as chat messages — enabling real-time external event awareness

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

MCP servers can send notifications/message to Claude Code, and Claude Code already receives them correctly — but never displays them in the chat UI. This means external events (GitHub webhooks, emails, CI status, timers) cannot reach the agent during a session.

Currently, AI agents are purely reactive — they only act when a human types a message. There is no way for the outside world to notify the agent of changes. Users must manually inform the agent about every external event: "CI failed", "someone commented on the PR", "you got an email".

This was previously requested in #3174, which received community support but was autoclosed and locked. The need has only grown since then — MCP Streamable HTTP is now in the official spec, and real server implementations exist that are blocked solely by this missing display capability.

Proposed Solution

Simply display notifications/message from MCP servers as chat messages in the UI.

When an MCP server sends a notification:

{
  "jsonrpc": "2.0",
  "method": "notifications/message",
  "params": {
    "level": "info",
    "logger": "github-webhook",
    "data": {
      "message": "PR #708: review comment added by @reviewer"
    }
  }
}

Claude Code would display it in the chat:

🔔 MCP [github-webhook]: PR #708: review comment added by @reviewer

The agent sees this as part of the conversation and can respond naturally — no new tools, no new protocol, no new API needed.

Primary target: Desktop app — Users keep it open during work sessions, making it a natural always-on receiver. When the app is closed, notifications simply stop — providing an intuitive on/off switch without any daemon behavior. CLI and remote mode would also benefit.

Implementation detail:

1. Claude Code already receives notifications/message via MCP transport (confirmed in #3174)
2. On receipt, format the notification and append it to the chat as a notification message
3. The LLM sees it in context and can choose to act or acknowledge
4. Desktop app closed = no notifications received = natural safety boundary

Optional enhancements (not required for MVP):

• Filter by log level (e.g., only show warning and above)
• User setting to enable/disable per MCP server
• Visual distinction for notification messages vs. user messages

Alternative Solutions

• Polling via scheduled tasks — Works but defeats the purpose of webhooks; adds latency and unnecessary API calls
• CLI non-interactive mode (claude -p) — Can be spawned by a webhook receiver, but loses session context and conversation history
• File-based mailbox — MCP server writes to a file, agent periodically checks; fragile and not real-time
• Remote mode — Potentially viable but not yet fully explored for this use case

None of these provide the seamless, real-time, in-session experience that simply displaying MCP notifications would achieve.

Priority

High - Significant impact on productivity

Feature Category

MCP server integration

Use Case Example

Scenario: Multi-engine code review with GitHub webhooks

1. I'm working with an AI agent in Claude Code Desktop on a feature branch
2. I push the branch and create a PR
3. A different AI engine (e.g., OpenAI Codex) reviews the PR and leaves comments on GitHub
4. My github-webhook-mcp server receives the webhook event
5. Currently: Nothing happens. I have to manually tell the agent "go check the PR for comments"
6. With this feature: A notification appears in chat: 🔔 MCP [github-webhook]: PR #708: review comment added by @codex-reviewer
7. The agent reads the comment, applies the fix, and pushes — all without me having to relay the information

This same pattern applies to:

• CI failure notifications → agent diagnoses and fixes
• Email arrival → agent drafts a response
• Calendar reminders → agent prepares relevant context
• File system changes → agent validates and warns

Additional Context

Prior art:

• #3174 — Same request, received community support, autoclosed/locked
• #1478 — Notification-driven auto-resume (autoclosed)
• #32504 — Inter-session communication (closed as duplicate of #32631)

Working implementation ready to connect:

• github-webhook-mcp — A production MCP server that receives GitHub webhooks and is ready to push notifications to Claude Code. Currently blocked only by this missing feature.

MCP Spec reference:

• Logging / notifications/message — The spec states: "Clients MAY: Present log messages in the UI"

Why this is high impact with low effort:

• No new protocol — notifications/message already exists
• No new tools — the agent just reads chat messages
• No security risk — same trust model as any MCP interaction
• Desktop-app-closed = off — no background execution concerns

This single change transforms AI agents from passive tools into event-aware assistants. The protocol is ready. The server implementations exist. The only missing piece is displaying a text message in the chat UI.