[FEATURE] Expose Claude Design annotations/comments via MCP (read, reply, resolve)

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

We drive Claude Design from Claude Code, not the other way around. Claude Code is where the real leverage lives: it holds the full business/domain context (the actual repo and its history), the connected MCP servers (Linear, GitHub, Slack, design systems, internal tools…), and persistent memory across sessions. So when a design gets reviewed, the agent that should read the feedback, reason about it against that context, and act on it is the Claude Code agent — not a human copy-pasting between two surfaces.

But the Claude Design MCP exposes project collaboration (add_member, list_members, update_sharing) and the generation chat (get_conversation), yet gives no access to the annotations / review comments left on a design preview. When a design is shared for review, reviewers annotate it in the web UI — and from Claude Code we can't read, reply to, or resolve any of it. We have to switch to the web UI, read comments manually, and re-transcribe them for the agent, losing all the context the agent already has. get_conversation returns the generation chat, not the review annotations.

Proposed Solution

Expose the full annotation lifecycle over MCP so the agent can own the review loop:

• Read — list_annotations(projectId, path?) / get_annotations(projectId) returning threads: author, target (file / element / coordinate), body, resolved state, timestamps.
• Reply / write — reply_annotation(projectId, annotationId, body) and create_annotation(projectId, target, body) so the agent can respond to a reviewer or raise its own note in place.
• Resolve — resolve_annotation(projectId, annotationId) once the agent has addressed the feedback (e.g. after applying the change in the repo).

This lets Claude Code close the loop end-to-end: pull the annotation → reason against repo/MCP/memory context → implement in the real code → reply and resolve — all in one agent session, no manual re-transcription.

Alternative Solutions

• Scraping the web UI with Claude for Chrome — today we drive the Claude in Chrome extension to open the shared design and read the annotations off the rendered page, then feed them back to the Claude Code agent. It works but it's brittle (DOM-dependent, breaks on UI changes), read-only in practice, and can't cleanly reply or resolve — a native MCP path would replace this hack.
• Reading annotations in the web UI and re-typing them for the agent, then manually resolving them back in the UI.
• Using a separate review surface outside Claude Design, which loses the tie to the design project.

Priority

Medium - Would be very helpful

Feature Category

MCP server integration

Use Case Example

1. The agent generates/iterates screens in a Claude Design project.
2. We share it (existing update_sharing/add_member); reviewers annotate specific screens.
3. From Claude Code the agent calls list_annotations(projectId) and pulls every open thread.
4. For each: it reasons against the real repo + connected MCP + memory, implements the change in code, then reply_annotation (what it did) and resolve_annotation (closes the thread) — the reviewer sees resolution without the human ever leaving the code loop.

Additional Context

Related to #73306 (generative MCP methods) — same "close the design↔code loop from the agent" theme, but this asks for the review-feedback path (read + reply + resolve), which #73306 does not cover.
Current MCP surface (none touch annotations): list_projects, get_project, list_files, read_file, write_files, copy_files, delete_files, get_conversation, put_conversation, list_members, add_member, remove_member, update_member_role, update_sharing, list_design_systems, get_claude_design_prompt, render_preview, finalize_plan, create_support_js.
Server: https://api.anthropic.com/v1/design/mcp.