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.

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.

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).

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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

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 }.

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 persisted simulation events in stream order. Paginated — use offset/limit to page through long runs instead of materializing the full event log.

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

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

Read model-swarm transcript memory for a run.

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

Summarize token and cost usage for a simulation run.

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

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

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.

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.

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.

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.

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.

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.

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.