Capture a Figma node and analyze it with configured AI vision.

Prereq: bridge + plugin connected; a vision-capable AI provider configured; spec-compliance mode needs the spec in the registry. Returns by mode — general: { summary, issues[], suggestions[], qualityScore }; accessibility: { summary, contrastIssues[], touchTargetIssues[], focusIssues[], wcagLevel }; spec-compliance: { summary, compliant, mismatches[], missingProps[], extraElements[] }. Errors: isError on missing key, no connection, bad node, or missing spec. Modes: general = visual polish; accessibility = WCAG checks of a frame; spec-compliance = rendered design vs saved spec before codegen. Core of the self-heal loop: create → capture_screenshot → analyze_design → fix → verify.

Audit interface design craft from local app-quality evidence or a screenshot artifact.

Returns: InterfaceCraftReport JSON — score, critique, dimensions, findings, topOpportunities (lenses: visual design, interface design, conventions, user context). Use before UI edits or after a redesign; pairs with diagnose_app_quality and audit_ux_tenets_traps.

Audit UX tenets and traps from app-quality evidence or a screenshot artifact.

Returns on success: UX audit JSON with score, tenetCoverage, trapRisks, findings, and recommendedTweaks. This tool does not modify source files.

Use this tool: when an agent needs a focused design critique packet for clarity, feedback, control, consistency, accessibility, error recovery, progressive disclosure, workflow fit, trust, and state continuity.

Capture a screenshot of a Figma node (or the current page) as image data.

Prereq: bridge + plugin connected (check_bridge_health); node IDs from get_selection or get_page_tree. Returns: { type: "image", data: base64, mimeType }. Feed into analyze_design; first step of the self-heal loop (CREATE → SCREENSHOT → ANALYZE → FIX). Prefer SVG for vector components, PNG for complex frames. Errors: isError if not connected or the node is invalid.

Check health of the Figma WebSocket bridge. Works with no plugin connected; never throws.

Returns: { status: "healthy"|"degraded"|"down", connected, clientCount, latencyMs, uptimeSeconds, port, error? } — clientCount 0 means no plugin open in Figma. Call this first before any Figma-dependent tool.

Check real source files for the objectively-checkable rules in skills/ATOMIC_DESIGN.md (composition, state, data-fetching, naming) and skills/MOTION_VIDEO_DESIGN.md (motion tokens, reduced-motion, GPU-safe properties) — a post-hoc, deterministic verification pass, the same mechanism a linter uses to enforce a style guide.

This does not read the skill docs at check time or make an agent obey markdown — the checkable rules are hand-extracted into regex/string checks. It closes the gap where nothing downstream ever notices whether an agent actually followed those docs. skills/DESIGN_SYSTEM_REFERENCE.md is a pure external-system catalog with zero checkable rules and contributes nothing here.

Prereq: none — no Figma, no AI, works entirely offline. Returns: { version, target, generatedAt, findings: [{ severity, rule, file, message, fix?, docRef }], summary: { critical, warning, filesChecked } }. Real enforcement requires wiring memi audit --skill-compliance into CI or a pre-commit hook — this MCP tool remains something an agent can choose not to call, same as any other tool.

Run the agent orchestrator on a natural-language design intent — classifies, builds a multi-step plan, executes it.

Prereq: Figma bridge only for Figma-touching intents. Returns: { success, plan: { steps[] }, results[], summary, errors? }; success=false with errors on failure (per-step failures do not abort the plan). Examples: "create a dashboard page with KPI cards, a chart, and a data table"; "audit button variants for WCAG contrast"; "pull design system, then generate all missing component specs". Be specific — name components, atomic levels, and target output.

Create or overwrite a spec in the registry (Zod-validated). Same-name specs are silently overwritten — check get_specs first.

Returns: Spec "<name>" saved (<type>). Errors: isError with Zod details on schema/JSON/type failures. Schemas — component: name, type, atomicLevel ("atom"|"molecule"|"organism"|"template"), purpose, props[], variants[], composesSpecs[] (atoms must be []), codeConnect{}; page: name, type, purpose, sections[]; dataviz: name, type, chartType, dataShape.

Scrape a public URL and extract its design system — parses CSS custom properties, colors, fonts, spacing, radii, shadows; the configured AI provider synthesizes a DESIGN.md.

Prereq: publicly accessible URL; configured AI provider for synthesis (pass raw=true without it). Returns (raw=false): DESIGN.md with Color System, Typography, Spacing, Borders & Surfaces, Component Patterns, Voice & Tone, Do/Don't, Tailwind Config Sketch. Returns (raw=true): { url, title, tokens: { cssVars, colors, fonts, fontSizes, spacing, radii, shadows, counts } }. Errors: isError if the URL is unreachable/has no usable CSS, or the key is missing in synthesis mode. Use to reverse-engineer a reference site's system or extract tokens for comparison.

Normalize design-systems-mcp corpus data into compact, deterministic agent context.

This read-only tool validates caller-supplied JSON and never fetches URLs, reads files, writes files, or executes corpus content. Use mode=corpus with a native manifest plus filename-keyed entries, or mode=category with the proposed category-manifest/v1 envelope. Returns byte-capped context plus inclusion counts.

Diagnose UI quality for an existing shadcn/Tailwind app from code or a public URL.

Returns on success: App-quality diagnosis V2 with scores, issues, evidence locations, affected files, confidence, effort estimates, fix categories, and app graph summary.

Use this tool: before planning UI fixes, exporting a registry, or giving an AI editor context on real app design debt.

Generate shadcn/ui + Tailwind code from a saved spec and write files into atomic design folders (atoms → components/ui/, molecules/organisms/templates → components//).

Returns: { entryFile, files[], generatedAt, findings[], critique? }. For page specs, critique is an AI layout score (0-100) + hierarchy/spacing/consistency notes when an AI provider is configured — informational only, never blocks. Errors: isError if specName is not found. isError with { blocked: true, findings } if a critical quality-gate finding (raw hex/color when tokens exist, a token-pair contrast failure, or a strict-mode skill-compliance violation) prevented the write — pass force:true to write anyway after reviewing the findings.

Compose one self-contained design-health report (HTML + markdown) from all persisted .memoire audits — app quality, UX tenets/traps, interface craft, skill compliance, and the score trend, with provenance badges, the not-assessed legend, and the active policy hash.

Prereq: run diagnose_app_quality (or the CLI audits) first so artifacts exist; missing sections are listed, never silently omitted. Returns: { html, markdown, score, sections[], missing[] }. Static content — write it wherever needed. redact=true strips evidence excerpts (paths stay) for NDA-safe sharing.

AI token usage and estimated cost for this MCP session (in-memory tracker; never throws; unknown when provider pricing is not configured).

Returns: { calls, inputTokens, outputTokens, estimatedCost, knownEstimatedCost, costComplete, unpricedCalls, summary }. Use to monitor spend from analyze_design, design_doc, or compose.

Get the hierarchical node tree of the current Figma file.

Prereq: bridge + plugin connected. Returns: array of pages { id, name, type: "PAGE", children[] }; child nodes { id, name, type, children? }. IDs feed capture_screenshot and analyze_design. depth=1 pages only, 2 (default) top-level frames, 3+ component internals — high depths may be slow on large files.

Return one shadcn registry-item.json-compatible item from the workspace.

Returns: files, targets, dependencies, cssVars, and Atomic Design metadata. Errors: isError if the item is unknown (discover names via get_shadcn_registry).

Load and return the project's user research V2 store — observations, findings, personas, themes, quantitative metrics, and quality metadata.

Prerequisites: None — reads from the local .memoire/research/ directory. Research data is populated by running memi research from-file, memi research from-stickies, memi research from-transcript, memi research web, or memi research synthesize. Returns an empty V2 store if no research has been imported yet.

Returns on success: Research store object with shape { version, sources, observations, findings, themes, personas, quantitativeMetrics, opportunities, risks, contradictions, quality, summary, methods }. Findings include auditable evidence links via evidenceObservationIds and evidenceSourceIds. Themes reference findingIds[].

Error behavior: Never throws — loads gracefully and returns an empty store if files are missing.

Use this tool: before running compose with a research-driven intent (e.g. "generate a dashboard based on user research"), to inspect what research context is available, or to verify that a research import or synthesis succeeded. Combine with compose to ground design decisions in actual user data. Research stores grow large — request only the sections you need (default is a summary with per-section counts).

Get the nodes currently selected in Figma with layout/style details.

Prereq: bridge + plugin connected; returns [] if nothing is selected. Returns: [{ id, name, type, width, height, x, y, layoutMode?, padding/sizing/itemSpacing?, fills?, strokes?, effects?, styles?, variantProperties? }]. Use for node IDs (capture_screenshot, analyze_design) or reading layout/variants before writing a spec. Errors: isError if not connected.

Build a shadcn registry.json-compatible index from the workspace (component specs; tokens map to a registry:theme item when present).

Returns: { $schema, name, homepage, items[] } with file targets, registryDependencies, cssVars. For a single item use get_registry_item.

Fetch the full body of one spec by name.

Returns: full spec JSON — ComponentSpec: atomicLevel, props, variants, composesSpecs, codeConnect, WCAG fields; PageSpec: sections, meta; DataVizSpec: chartType, dataShape. Errors: isError if the name is not found (list names via get_specs).

List all saved specs (cheap summary operation).

Returns: [{ name, type: "component"|"page"|"dataviz"|"design"|"ia", purpose? }]; [] when none exist. Use before create_spec (overwrite check) or generate_code; fetch a full body with get_spec.

Get design tokens from the local registry, optionally filtered.

Prereq: none — local read; run pull_design_system if empty. Returns: [{ name, type: "color"|"spacing"|"typography"|"radius"|"shadow"|"other", values (keyed by mode), cssVariable? }]; [] when none. format "dtcg" returns the same tokens as a W3C Design Tokens (DTCG) document instead — nested groups, $type/$value, lossless via $extensions. Filter by type/name to keep payloads small on large token sets. For a Tailwind-ready mapping use sync_design_tokens.

Predict text layout — height, line count, overflow, breakpoint behavior — via Node canvas. No browser, Figma, or AI needed.

Returns: { height, lineCount, lines[] }; plus { overflow } when containerHeight is given; plus { breakpoints: { mobile, tablet, desktop } } when checkBreakpoints=true. Never throws (0 height / 1 line for unparseable fonts). Use to verify labels or body copy fit fixed containers or maxLines constraints before generating designs or code.

Write Mermaid Jam-ready FigJam source artifacts from research or a simulation run.

This is source + open friendly: it writes .mmd/.md files under .memoire/mermaid-jam and returns next steps. It does not attempt clipboard or direct paste automation.

Build a dry-run UI fix plan from diagnosis evidence and app graph data.

Returns on success: { patches[], summary, caveats[] } where every patch includes risk, confidence, affected files, operations, and writeSafe. This tool never modifies source files.

Use this tool: to decide what a human or coding agent should patch before calling memi fix apply or making manual edits.

Prepare a compact, local-first Apple-platform design and verification brief.

Returns: mission, skill triggers, availability policy, Xcode preflight, design checks, build/test commands, and handoff requirements. Use before creating or changing SwiftUI, SwiftData, App Intents, Liquid Glass, or concurrency-sensitive UI. This tool does not run Xcode or mutate files.

Prepare a cost-aware design-agent brief before editing UI.

Returns on success: JSON with mission, evidenceCommands, designRules, costControls, compatibility installs, MCP command, Agent Skills command, and handoffChecklist.

Use this tool: as the first MCP call when a coding agent is asked to design, polish, audit, refactor, or generate interface code. It is local-first and does not call Figma, browsers, or models.

Pull the full design system from Figma (tokens, components, styles) into the local registry.

Prereq: Figma bridge running + plugin connected — verify with check_bridge_health; start via memi connect. Returns: { tokens, components, styles, lastSync }. Errors: isError "Figma not connected" if no plugin. Run at session start or after designer changes; inspect results with get_tokens.

Pull the design system from Figma via REST API — no plugin or bridge required.

Prereq: FIGMA_TOKEN and FIGMA_FILE_KEY env vars. Returns: { tokens, components, styles, lastSync }. Errors: missing env vars, or Figma API errors (403 = bad token, 404 = bad file key). Use in CI/headless; equivalent to memi pull --rest.

Preview a research-backed vibe design package from ResearchStore V2 plus an optional simulation run.

Returns on success: { package } with brief, Atomic Design specs, evidence ids, Mermaid Jam-ready source artifacts, and warnings. This tool is non-mutating; call research_generate_specs to write specs or mermaid_jam_export to write FigJam source files.

Write research-backed Atomic Design specs generated from ResearchStore V2.

Prerequisites: Call research_design_package first to preview. This tool requires approved=true to make the write explicit. Writes DesignSpec, IASpec, PageSpec, ComponentSpec, and DataVizSpec objects through the Memoire registry.

Run a deterministic design-system audit (WCAG contrast, token completeness, spec accessibility) and return structured findings.

Prereq: none — token/spec level, no Figma, no AI. Returns: { success, results: issues[], score, level, summary }. focus="contrast" narrows to token contrast pairs; focus="skill-compliance" checks real source files against ATOMIC_DESIGN.md/MOTION_VIDEO_DESIGN.md's checkable rules. vs analyze_design: run_audit = systematic spec/token compliance; analyze_design = AI vision review of a live Figma frame.

Preview or write a spec-first Atomic Design scaffold for agent-created files.

Default is non-mutating: approved=false returns a dry-run JSON plan with the exact spec path, guardrails, and next generation commands. To write the spec, pass approved=true. This writes only the registry spec; generated code still requires generate_code or memi generate, so quality gates stay intact.

Preview or write a deterministic SwiftUI feature scaffold.

Default approved=false is non-mutating and returns every planned path and file body: Memi iOS spec, SwiftUI view, optional screen model, preview, and Swift Testing file. Set approved=true only after reviewing the plan. Writes never alter Xcode project files and refuse to overwrite existing files.

Compare completed simulation runs by adoption, confidence, evidence coverage, risk, and cost.

Summarize token and cost usage for a simulation run.

Convert a simulation report into a product-spec impact artifact that agents can paste into specs or handoff docs.

Generate a 20-60 agent model-swarm cohort from Memoire research evidence without starting a run.

Interview a simulated product stakeholder from a completed local or model-swarm run.

List persisted simulation runs with lightweight summaries. Use this to discover runIds for simulation_status, simulation_stream, simulation_transcript, simulation_costs, simulation_report, and simulation_compare.

List Codex-first model profiles available to Memoire model-swarm simulations. Live model execution is opt-in; unavailable providers automatically fall back to deterministic clean-room simulation.

Create a clean-room product simulation scenario from Memoire research evidence.

Prereq: research/store.v2.json or a ResearchStore JSON string. Local TypeScript simulation core only; adapter=model-swarm plans Codex-first profiles with deterministic fallback. Returns: { scenario (agents, variables, graph, evidenceFindingIds), warnings }.

Export a simulation report with recommendations, risks, assumptions, events, interviews, and evidenceFindingIds.

Run a prepared local or model-swarm product simulation scenario.

Prerequisites: Call simulation_plan first and pass the returned scenario.id.

Returns on success: SimulationRun with status, events, eventCount, and persisted run id.

Plan and run multiple model-swarm hypotheses, then compare outcomes for product-spec decision work.

Read a local simulation run status from .memoire/simulations/runs.

Read persisted simulation events in stream order. Paginated — use offset/limit to page through long runs instead of materializing the full event log.

Read model-swarm transcript memory for a run.

Map registry tokens to a Tailwind theme.extend object; optionally import a W3C DTCG token file first.

Prereq: tokens in the registry (pull_design_system first) — or pass dtcgFile to import them here. Never throws — returns {} when empty. Returns: partial theme (colors, spacing, fontSize, borderRadius, boxShadow) using var(--token) references; keys from the last token-name segment; "other" tokens skipped. With dtcgFile also { imported, warnings }. vs get_tokens: get_tokens = raw data for inspection (format "dtcg" exports the DTCG document); this = paste-ready Tailwind patch.

Update a design token value in the local registry, optionally pushing to Figma.

Prereq: token must exist (names via get_tokens); Figma connection only for pushToFigma. Returns: { updated: true, name, pushedToFigma, reason? } — a requested-but-skipped or failed push is reported in reason, never silently dropped. Errors: isError if the token name is not found. For bulk Tailwind mapping use sync_design_tokens.