MCP tools
Every tool a coding agent can use on M1rror's MCP server, grouped by area and generated from the same action registry the server uses.
On this page
Tools are M1rror's governed actions: the same policy-checked actions the app uses. The server lists only the tools an agent's grant allows, so an agent with only m1rror:read sees just the reading tools and the few listed below.
Your agent sees only the tools in its connection's tool profile. Connections from Connect your agent and OAuth use the implementer profile, a set of 14 tools for building an approved release and reporting back; the list below is the full set.
Each tool's description in your agent also states the permission it needs and its side effect. Reading needs m1rror:read. A tool that changes something requires m1rror:draft, except three that need only m1rror:read: taste_cancel_run (cancel a run), taste_request_release_snapshot (take pictures of a release) and taste_prepare_draft_pictures (draw pictures of a draft).
Conventions
- Projects first. Most tools take a
project_id. Start withtaste_list_projectsandtaste_get_project_context, ortaste_get_agent_brieffor a ready-made brief. - Approved only.
taste_get_agent_briefandtaste_get_implementation_briefpoint only at the latest approved release. When nothing is approved they say so, and a newer release still in review is named as not approved, so an agent never builds from it. - Optimistic concurrency. Tools that change a revisioned object take an expected revision and fail with
stale_revisionif someone changed it first: read again, then retry. - Long work is a run. Tools that start work return a run you can follow with
taste_get_run_statusand cancel withtaste_cancel_run. - Human-only actions aren't tools. Approving releases, authorising and starting builds, opening pull requests and anything that needs explicit human confirmation never appear here.
All tools
223 tools in 50 areas. An agent only sees the tools its grant allows.
Design agent
| Tool | What it does | Kind |
|---|---|---|
taste_list_directions | List design directions for a project with their tokens, rationale and keep/avoid status. | Read |
Agent setup
| Tool | What it does | Kind |
|---|---|---|
taste_get_agent_brief | A ready-to-use brief for an external coding agent working on one project: which MCP servers to connect, the exact project to target, what the project contains now, the tools to call first and recipes filled in for it. | Read |
Attachments
| Tool | What it does | Kind |
|---|---|---|
taste_get_attachment | Get a prompt attachment: its type, name, size, which message it was sent with and whether it was saved as a reference. Text attachments include their text (up to 20,000 characters). | Read |
taste_import_attachment | Upload a file an agent already has as a prompt attachment for a project (base64; image, PDF, TXT/Markdown/CSV/JSON or MP4/WebM, up to 20 MB; the type is decided from the bytes). Use the returned id with taste_save_attachment_as_reference, or give it to a person to send with a message. | Draft |
taste_save_attachment_as_reference | Add an image or video attachment to the project’s References (with a note that it came from a prompt). PDFs and text files stay with the conversation. Saving twice returns the same reference. | Draft |
Usage
| Tool | What it does | Kind |
|---|---|---|
taste_get_usage_status | Current plan, usage units this period and whether a payment problem needs attention. | Read |
Board
| Tool | What it does | Kind |
|---|---|---|
taste_create_board_object | Place an object on the project board: a reference card, note, screen frame, component, direction card or group. Position is presentation metadata only. | Draft |
taste_get_board | Get every live board object in a project (references, notes, screens, components, directions, groups) with the current scene sequence. | Read |
taste_update_board_objects | Move, resize, re-order or edit board objects in one batch. Each item carries the version it was based on; any stale item rejects the whole batch with 409. | Draft |
Brand fonts
| Tool | What it does | Kind |
|---|---|---|
taste_export_brand_fonts | Export the brand fonts a project's design system uses: `fonts.css` with @font-face rules, and with format zip the font files too (fonts/<family>-<weight>.<ext>). Only fonts whose licence was confirmed are exported; the others are listed with the reason. | Read |
taste_list_brand_fonts | List the workspace's brand fonts: family, weight, style, format, the scripts each file covers and its licence status (fonts whose licence nobody confirmed are drawn nowhere). Includes signed preview URLs for confirmed fonts. | Read |
Brand versions
| Tool | What it does | Kind |
|---|---|---|
taste_compare_brand_versions | What changed in a brand's own token layer between two revisions (`from` older, `to` newer; `to` defaults to the newest): tokens it started setting, changed, removed, or stopped naming so they are inherited again. It compares what the brand itself says, not the values inherited from brands above it. | Read |
taste_get_brand_version | One saved revision of a brand's own token layer: the partial DTCG document as it was saved. Revision 0 is the empty layer a brand starts with. | Read |
taste_list_brand_versions | A brand's version history: every saved revision of its own token layer, newest first, and which version each surface uses. Surfaces always draw the newest version while people work; `released` is the version the surface's newest release was made with (null when no release of that surface recorded one). | Read |
Brands
| Tool | What it does | Kind |
|---|---|---|
taste_export_brand_tokens | Export a brand's resolved tokens (its foundation and every brand above it, then the brand itself) in any token format: CSS, TypeScript, JSON, DTCG (`layers=true` keeps the layer structure), Markdown, Tailwind, React Native, SwiftUI, Android and Jetpack Compose, or the icon formats. | Read |
taste_get_brand | One brand: its own token layer (only what it sets or removes), the resolved token set with the layer that set each token (`layer`: the foundation, a parent brand or this brand), and where it is used. | Read |
taste_get_brand_impact | Where a brand is used: every active surface (with its project) that uses it or a brand that inherits from it. A change to the brand changes all of them. | Read |
taste_get_surface_tokens | A surface's resolved tokens with provenance: each token's `layer` names where its value comes from (the foundation, a brand, the project's system, or this surface's own override) and the layers it overrode. A surface with a brand resolves foundation → brand → its overrides; without one, the project system → its overrides. | Read |
taste_list_brands | The workspace's brand library: the foundation brands and the brands that inherit from them (`parent_brand_id`), each with how many surfaces use it. A surface with a brand resolves its tokens foundation → brand → the surface’s own overrides. | Read |
Website capture
| Tool | What it does | Kind |
|---|---|---|
taste_estimate_app_capture | Estimate the variants (pages × viewports × colour schemes) and usage units an app capture would take, without starting it. | Read |
taste_get_app_capture | Get an app capture with its report: palette with roles, type scale, spacing, radii, shadows, motion, breakpoints, component patterns with states, interaction/keyboard notes, evidence confidence and limitations. | Read |
taste_list_app_captures | List app captures for a project with their run status. | Read |
Capture data
| Tool | What it does | Kind |
|---|---|---|
taste_list_capture_data | Test data for screen captures in a project: recordings, staging-server access, starter test data, pins, and which source each screen’s requests use (staging > recorded > app mocks > starter). Credentials are never included. | Read |
taste_pin_capture_data | Choose the test data a project (or one screen, by its screen id) uses for captures, whatever would win by default. source_id null clears the pin. A pinned source that cannot answer a request falls back to the default order for that request. | Draft |
taste_regenerate_capture_starter | Put back the starter test data M1rror last made from the app’s types, replacing any edits. M1rror makes it again on every code scan; if none was made yet, scan the code first. | Draft |
taste_set_capture_starter | Replace the starter test data of a project (made by M1rror from the app’s types) with an edited copy: { sources: [{ key, pattern, method, body, rows? }] }. Always labelled “Starter test data made by M1rror”; never release evidence. | Draft |
taste_start_capture_staging_check | Check that the staging servers allowed for captures are reachable: each host must resolve to public addresses, then one HEAD (or GET) to / with the saved credentials. Only the status code is recorded. Free; a run. | Draft |
Code tokens
| Tool | What it does | Kind |
|---|---|---|
taste_get_code_tokens | The newest read of the repository's design tokens (files, formats, counts, what was not read and why), the read in progress, and the suggested plan for starting the System from them: which System roles map to which code tokens, conflicts with the System's current values and tokens that cannot be imported. | Read |
taste_preview_code_token_import | Preview starting the System from code with a mapping (System role → code token, or null to unmap), conflict choices (code or keep), exclusions and removals. Returns every token with its status, the conflicts as Code / Reference / Proposed, and a plan digest to apply. Saves nothing; free. | Read |
taste_read_code_tokens | Read the connected repository's design tokens (CSS variables, Tailwind, SCSS/Less, DTCG/Style Dictionary JSON, MUI, vanilla-extract, styled-components and React Native themes) at the tracked branch's head, with each token's own name, file and line. Free; a run. A commit already read is reused. Several repositories: pass repository_id. | Draft |
Comments
| Tool | What it does | Kind |
|---|---|---|
taste_add_comment_attachment_to_board | Put one attachment of a comment on the Board as a reference card that links back to the comment ("From a comment on …"). Links and images become references with the Board’s default rights (not sent to AI models until someone clears them); a project reference keeps its own rights. Already on the Board: nothing changes. | Draft |
taste_create_comment_task | Make a comment thread a task, with an optional assignee (a project member: see taste_list_mention_candidates) and due date (YYYY-MM-DD). The task’s status is the thread’s: it is open while the thread is open and done once the thread is resolved. The assignee is notified. A task is never an approval. | Draft |
taste_create_comment_thread | Start a comment thread anchored to a board object, reference, screen, component, direction or release. Optionally pin it at a normalized {x,y} point inside the target. On a screen the anchor also takes the state and device it was made in and the element under the point ({ node_id, x, y } inside the element); the server records the element’s layer path and label. Optional: markup (shapes in CSS pixels from the element’s or screen’s top-left corner), attachments (a link, an uploaded file, or a project reference; add_to_board, default true, also puts them on the Board as references linked back to the comment). With `live` (an element picked in a live preview), the target may be omitted: it is resolved to the screen whose route matches, else a confirmed component, else the page (app_route). | Draft |
taste_get_comment_thread | Get one comment thread with all replies and its anchor. | Read |
taste_list_comment_tasks | List the design tasks in a project (comment threads made tasks), newest first, with what each is on (target, and on a screen the element, state and device), the assignee, the due date and the discussion. Filter by status (open, done, all) and assignee (a member id, "me", or "none" for unassigned). | Read |
taste_list_comment_threads | List comment threads in a project, optionally for one target, filtered by open/resolved status. Comments are discussion, never approvals. | Read |
taste_list_mention_candidates | List the project members who can be @mentioned in comments (names only). | Read |
taste_reply_comment_thread | Reply to a comment thread. Replying to a resolved thread reopens it. Optional: markup and attachments as on taste_create_comment_thread, and links naming what the reply is about (an agent that changed a screen links the screen, the state and the revision its change produced). Replying never resolves a thread. | Draft |
taste_set_comment_task_status | Mark a task done or open it again. Done resolves its comment thread; open reopens it (they are one status). A coding agent that fixed what a design task asks for marks it done; say what changed with taste_reply_comment_thread first (a reply after it is done reopens it). Finishing a task never approves anything. | Draft |
taste_update_comment_task | Change a task’s assignee or due date (null clears it). A new assignee is notified. To finish or reopen a task use taste_set_comment_task_status. | Draft |
Credits
| Tool | What it does | Kind |
|---|---|---|
taste_get_credits | Generation credit balance: included credits this month and purchased credits by expiry, credits on hold for running generations, the daily limit, and the packs that can be bought. 1 credit = $0.01. | Read |
Design sources
| Tool | What it does | Kind |
|---|---|---|
taste_get_agent_setup | MCP endpoints and recipes for connecting your own agent to M1rror plus the official Figma and Mobbin MCP servers. | Read |
Design systems
| Tool | What it does | Kind |
|---|---|---|
taste_compare_design_systems | Compare two saved design systems (or one with the tokens in use, `b: "in_use"`): tokens added, removed and changed, with before and after values. | Read |
taste_get_design_system | One saved design system: its name, source, the whole token document and the compiled values, contrast checks and diagnostics, for previewing it without using it. | Read |
taste_list_design_systems | The saved design systems of a project (each reading of references, each stricter or softer variation, each copy), newest first, with which one is in use, whether the project still has only the starter styles, and whether the last switch can be undone. Switching never changes a release. | Read |
Evidence
| Tool | What it does | Kind |
|---|---|---|
taste_submit_evidence | Attach a check result you produced to an implementation run (run_id) or a PR linked to a release (link_id). Stored as externally submitted; never changes a run, contract or approval. | Draft |
Figma plugin sync
| Tool | What it does | Kind |
|---|---|---|
taste_figma_plugin_session | For the M1rror Figma plugin: the workspace this agent token belongs to, the projects it can sync and whether it may pull and push. | Read |
taste_figma_sync_compare | Compare a Figma file’s local variables (sent by the M1rror Figma plugin) with the project’s tokens, three ways against the revision the file was last pulled at. Lists changes for Figma, changes for M1rror and per-token conflicts. Saves nothing. | Read |
taste_figma_sync_pull | Plan a pull into Figma for the M1rror Figma plugin: the variable creates, updates and deletes that bring the file to the current revision, honouring per-token conflict choices. The plugin applies them; M1rror changes nothing. | Read |
taste_figma_sync_push | Push Figma variable changes (sent by the M1rror Figma plugin) to M1rror as a proposal. Only tokens changed in Figma since the last pull, plus conflicts resolved in Figma’s favour, are proposed; a person applies or discards the proposal in the System studio. | Draft |
taste_figma_sync_record_pull | Record that the M1rror Figma plugin applied a pull: the revision the file now matches (the next merge base) and the variable ids linked to token paths. | Draft |
Image and video generation
| Tool | What it does | Kind |
|---|---|---|
taste_get_generated_asset | One generated image, vector or video with its prompt, model and whether it was saved as a reference. | Read |
taste_get_generation | A generation run: status, progress events, usage units and the media it produced. | Read |
taste_list_generated_assets | Generated media (images, vectors, videos) in a project, newest first, optionally filtered by kind. Cursor-paginated. | Read |
taste_list_generation_models | The generation models M1rror offers, grouped by kind (image, vector, video), task (create, edit, upscale, remove_background, vectorize, animate) and tier (recommended, fast, quality), each with what it is best for, the inputs it takes and the credits one output costs (1 credit = $0.01), plus the workspace’s credit balance. Use taste_quote_generation for an exact quote. | Read |
taste_list_generations | Generation runs for a project, newest first (`active=true` for those still running). | Read |
taste_quote_generation | How many credits a generation would use before starting it (1 credit = $0.01), the balance after it, and whether the balance and today’s limit allow it. The final charge is never more than the quote; failures, cancellations and outputs withheld by the safety checker are not charged. | Read |
taste_save_generated_asset | Save a generated image, vector or video to the project’s References board, with its model and prompt as provenance. Vectors are rendered to PNG for the board; the SVG stays downloadable from the media. Videos keep the clip and get a poster frame (what analysis and image tools see). Rights: provider agreement, exportable, not public. | Draft |
taste_start_generation | Generate images, vectors (SVG) or a short video with one of M1rror’s generation models (see taste_list_generation_models): create from a prompt, edit or combine references, upscale, remove a background, vectorize, or animate a reference. References must be cleared for model use. Holds the quoted credits (1 credit = $0.01) and runs in the background; only delivered outputs are charged, never more than the quote. Results appear in the project’s Media, and on the References board with save_to_board. | Draft |
Icons
| Tool | What it does | Kind |
|---|---|---|
taste_clear_icon_override | Reset one semantic icon to the default set's equivalent (removes the override; removes a custom icon). New token revision (or a proposal for agents). | Draft |
taste_get_icon_library | Get a project's icon library at a token revision: the default set and, for every semantic icon (home, search, settings, …), the resolved Iconify id, its SVG and whether it is the default, an override, a custom icon, a fallback (the set has no equivalent) or missing. `preview_set` shows the result of switching sets without saving. | Read |
taste_get_icons | Get sanitized SVGs (currentColor) for Iconify ids ("prefix:name") from the supported icon sets. Unknown ids are listed in `not_found`. | Read |
taste_list_icon_sets | List the icon sets a project can use (Lucide, Phosphor, Heroicons, Tabler, Material Symbols, …) with license, style, icon count, coverage of the semantic vocabulary and sample SVGs, plus the semantic vocabulary itself. | Read |
taste_search_icons | Search icons across the supported icon sets (or one Iconify prefix such as "ph" or "lucide") via Iconify. Returns Iconify ids with sanitized SVGs; use an id as a per-icon override. | Read |
taste_set_icon_override | Use a specific icon for one semantic name ("search" → "ph:magnifying-glass"), mixing sets. Names outside the vocabulary become custom icons. The icon must exist in a supported set. New token revision (or a proposal for agents). | Draft |
taste_set_icon_set | Switch the default icon set: every semantic icon is remapped to its equivalent in the new set (icons the set lacks fall back to the previous set, clearly flagged). Saved as a new token revision based on `expected_revision`; agents create a proposal for a person to apply. | Draft |
Build plans and builds
| Tool | What it does | Kind |
|---|---|---|
taste_get_implementation_contract | Get an implementation contract with its digest, scope, budget and authorization status. | Read |
taste_get_implementation_run | Get an implementation run with its contract, verification evidence and branch/PR status. | Read |
taste_list_implementation_contracts | List implementation contracts for a project. | Read |
taste_list_implementation_runs | List implementation runs for a project. | Read |
taste_prepare_implementation | Prepare a draft implementation contract from an approved release: base SHA, allowed/forbidden paths, invariants, checks and budget. Not an execution authorization. | Draft |
Implementation lifecycle
| Tool | What it does | Kind |
|---|---|---|
taste_list_implementation_changelog | List the changelog of a project: one entry per merged implementation pull request (release version and digest, PR number and link, merge commit, who merged it, what changed), newest first, with any revert pull request opened for it. | Read |
Live previews
| Tool | What it does | Kind |
|---|---|---|
taste_get_live_session | A live preview: status (booting, ready, paused, ended, failed), tier, ref, data mode, and the meter (running minutes, credits so far, held). Never returns viewer links or machine tokens. | Read |
taste_list_live_sessions | Live previews of a project, newest first: active ones by default, or every recent one. | Read |
taste_quote_live_session | What a live preview of the app would cost before starting it (1 credit = $0.01): the start charge, credits per running minute, what is held (start + the first 15 minutes), included live credits and balance left, the session cap and idle rule, or why it cannot start now (insufficient_credits, daily_cap_reached, credit_debt, concurrency_limit, capacity_full, gated, kill_switch). `built` previews cost one build per commit (reused by every viewer) and nothing to browse. | Read |
Live preview feedback
| Tool | What it does | Kind |
|---|---|---|
taste_list_live_feedback | List comments people pinned to elements of the live app (open by default): the comment, the page route, the element selector and text, the React component and its source file when M1rror matched it, device, theme, test data, the code version (ref), and picture URLs (approximate in-page crop, exact replayed crop). Use it to find what to change, then propose the change. | Read |
Languages
| Tool | What it does | Kind |
|---|---|---|
taste_add_locale | Add a language (BCP 47, e.g. de, pt-BR, zh-Hant) to the project. The first language added becomes the source unless strings already exist in en-US, which then becomes the source first. | Draft |
taste_clear_translation | Remove the translation of one string in one language (reject an AI suggestion). The string becomes missing. | Draft |
taste_create_string | Add a custom source string (any key outside screen. and store.) or a glossary term (key glossary.<slug>; do_not_translate keeps it as written in every language). | Draft |
taste_estimate_translation | How many strings an AI translation would cover per language and the usage units it reserves (2 units per language per batch of up to 80 strings; settled by actual model usage, never more). | Read |
taste_export_strings | Export strings as a file: i18next-json (nested), i18next-json-flat, android-xml (strings.xml), xcstrings (Apple String Catalog, every language in one file), apple-strings (.strings), xliff-1.2 or xliff-2.0. `reviewed_only` leaves out machine, draft and stale translations. The glossary is not exported. | Read |
taste_get_localization | Languages overview: project locales (source first) with progress per locale (translated, reviewed, machine, draft, stale, missing), string groups (screens, store, custom), unused screen strings, glossary size and whether AI translation is available. | Read |
taste_import_strings | Import translations for one language from i18next JSON (nested or flat) or XLIFF 1.2/2.0. Validates placeholders and limits, reports unknown keys and conflicts, and never overwrites a reviewed translation unless overwrite_reviewed is true. dry_run (default) only reports. | Draft |
taste_list_locale_options | Languages that can be added (every App Store and Google Play language plus common BCP 47 tags) with display names and store codes. | Read |
taste_list_strings | List source strings with one target language side by side. Filters: status (missing, stale, machine, draft, reviewed, needs_review = machine or draft, unused), group (screen:<screen_id>, store, custom, glossary; default everything but the glossary) and q (search key, source and translation). Cursor pagination by key. | Read |
taste_list_translation_runs | Recent AI translation runs for the project with progress, per-language results and failures. | Read |
taste_pseudo_localize | Generate a pseudo-locale without a model: en-XA (accented, ~35% longer, bracketed — finds truncation and hard-coded text) or ar-XB (right-to-left). Adds the locale if needed and overwrites its strings. | Draft |
taste_set_translation | Write or edit the translation of one string in one language. Saved as reviewed when a person writes it; text written by an agent is saved as a draft for a person to review. Attributed to the caller. Rejected when placeholders/ICU syntax differ from the source or the text exceeds the character limit. | Draft |
taste_sync_strings_from_screens | Extract user-visible text (text, label, title, placeholder, description, helper text, alt, …) from every screen into source strings keyed screen.<screen-slug>.<node-id>.<prop>. Changed text makes existing translations stale; strings no longer on any screen are marked unused (not deleted). `dry_run` previews the summary. | Draft |
taste_update_string | Edit a source string: text of custom strings and glossary terms (translations become stale), the translator note of any string, the character limit of non-store strings and do-not-translate of glossary terms. | Draft |
Pull request checks
| Tool | What it does | Kind |
|---|---|---|
taste_get_pr_check | One pull request design check: verdict, findings with file and line, what was checked, and history. | Read |
taste_get_pr_check_settings | Pull request design check settings for the workspace (on/off, blocking, drafts). | Read |
taste_list_pr_checks | Pull requests M1rror checked against the design system for a project: latest result per pull request, with how results reach GitHub. | Read |
taste_start_ci_check | Design-check one commit against a base, for CI (1 unit if UI changed; repeats are reused). | Draft |
Projects
| Tool | What it does | Kind |
|---|---|---|
taste_get_project_context | Get a project with its brief, platform and current draft revision. | Read |
taste_list_projects | List, search and filter projects in the workspace. `q` matches name, repository and product; filter by `status` (awaiting, approved, drafting, failing), `type` (repository, idea, design_system, sample), `platform`, `owner`, `starred`, `mine`; sort by opened, edited, name, created or status. Pages with `cursor`. | Read |
Design system from a reference
| Tool | What it does | Kind |
|---|---|---|
taste_export_reference_system | The hand-off bundle for a design draft: a brief for a coding agent (DESIGN.md), the design as JSON, and the tokens as CSS variables, a Tailwind theme, a React Native / Expo theme and W3C design-tokens JSON. Works with no model, repository, sandbox or GitHub App. | Read |
taste_get_reference_system | A design draft made from references: every finding with its confidence, evidence region and whether it was taken automatically or is asking, the contrast checks, fonts, and (with include_tokens) the token document it would become. | Read |
taste_list_reference_systems | Design drafts made from references in this project, newest first. | Read |
taste_make_reference_variations | Make a stricter (sharper corners, quieter shadows, tighter colour) and a softer (rounder, more lift) version of a design draft. Each is saved as its own named design system of the project ("Mochi · stricter"), next to the reading itself, to preview, compare and switch to in System. Nothing is put in use; no model is used and no usage is charged. | Draft |
taste_plan_reskin | Map a design draft onto the app already imported into this project, without changing anything: which token values change (before and after), which imported components and screens are affected and whether each is bound to code, and the order to re-skin in (tokens first, then components, then screens). Also reports how far the pull request path has come (release, approval, contract, run, pull request) and the gates that are open or closed: a connected repository, the GitHub App with write access, and the cloud workspace. | Read |
taste_prepare_reskin_contract | Re-skin, step 2 of the pull request path: from the approved release, prepare the draft implementation contract for the connected repository: base commit of the tracked branch, the files that may change (tokens file, components and pages, plus the source files of bound affected components), forbidden paths, checks and budget. It authorizes nothing: a person authorizes this exact contract in Implement, and a second approval opens the pull request. Needs a connected repository (otherwise gated_capability). | Draft |
taste_prepare_reskin_release | Re-skin, step 1 of the pull request path: capture the applied draft (the project design as it now stands) as a new, immutable, digest-bound release candidate. It is not approved: a person with review authority approves it in Review. An unchanged design reuses the existing release; a changed design is a new release. Requires the draft to be applied. | Draft |
taste_preview_reference_system | Before reading references into a design system: which pictures a model may read, whether the vision model is set up, how many batches of 6 pictures it reads in, and the most it costs in usage units. Reads nothing and charges nothing. | Read |
taste_read_mobbin_flow | Import a Mobbin flow as references and start reading it into a draft design system, in one step. The order you give is the order of the screens and is kept as the flow. Two ways in: `screens` (chosen through the Mobbin bridge; people only, needs the bridge enabled and connected, otherwise gated_capability) or `images` (screens your own agent fetched with the official Mobbin MCP, sent as base64 with their mobbin.com URL). Mobbin screens are licensed material: they are read by the vision model only when a person sets `allow_model_reading` (agents cannot decide that; without it only colours are measured). Starts a metered run (up to 6 usage units per batch of 6 screens; colours alone 1). Nothing is added to the design system until the draft is applied. | Draft |
taste_start_reference_system | Read one or more reference pictures into a draft design system. Colours are measured from pixels; with the vision model set up, type, shapes, components and screens are read too, each with a confidence and the region it came from. Starts a run (up to 6 usage units per batch of 6 pictures, up to 24 pictures; colours alone 1). Nothing changes in the design system until the draft is applied. | Draft |
References
| Tool | What it does | Kind |
|---|---|---|
taste_add_reference_link | Save a link reference (canonical URL + your title and rationale). The page is not fetched or copied; it stays a link. Optionally say where it came from in `source` (figma, mobbin, web or upload); Mobbin links get the licensed-catalog rights preset. | Draft |
taste_analyze_reference | Start a reference analysis run: extracts a color palette and deterministic visual traits (tone, saturation, contrast, density) marked as inferred. Uses 1 usage unit; no model receives the image. | Draft |
taste_annotate_reference | Record what to keep, what to avoid, or a note about a reference, optionally for a normalized crop region and a named quality (e.g. "typography"). | Draft |
taste_export_references | Build an export manifest for the project references. Originals are included only when may_export_original is true; others are listed as source links with the reason they were excluded. | Read |
taste_get_reference | Get one reference with rights, provenance, palette, inferred traits, annotations and analysis status. | Read |
taste_import_reference_image | Save an image an agent already has (for example a Figma frame export or a Mobbin screen fetched through the official MCP servers) as a private reference. Send the bytes as base64 (PNG, JPEG, WebP, GIF, AVIF or SVG, ≤ 15 MB) and say where it came from in `source`. Mobbin screens are stored as licensed material: visible to the workspace, never exported or shared. | Draft |
taste_import_reference_url | Import a pasted image or PDF link as a reference: the server fetches it (public addresses only, ≤ 15 MB, redirects checked) and stores it like an upload. A link that is not an image or PDF is refused with reason not_an_image, or saved as a link reference when if_not_image is "link". Figma links need the Figma integration (gated_capability, G02, when it is not set up). | Draft |
taste_list_reference_providers | List external reference catalogs and whether each is enabled or gated. | Read |
taste_search_reference_provider | Search an external reference catalog. Gated providers return a gated_capability error, never results. | Read |
taste_search_references | Search the project reference library by title, tags, rationale, inferred traits and annotations. Returns provenance, rights and which observation matched. Cursor-paginated. | Read |
Release snapshots
| Tool | What it does | Kind |
|---|---|---|
taste_compare_release_pictures | Compare the pictures of a release with another release (`against`: its id) or with the current draft (`against: "draft"`) pixel by pixel, per screen, at one size (mobile, tablet or desktop): which screens changed and by what share of the picture, with both pictures and a highlighted difference. Sides without pictures say why (no snapshot for that version, still being drawn, found only in code). | Read |
taste_get_release_snapshot | The pictures taken of a release when it was published (every screen, Default state, at Phone, Tablet and Desktop size), bound to its digest: ready with each picture, being taken, blocked (no browser on this server), failed, or none (a release published before snapshots existed). | Read |
taste_prepare_draft_pictures | Draw the current draft's screens (Default state) at the given sizes so a release can be compared with the draft, picture by picture. Free; only pictures not already drawn for exactly this draft are queued. | Draft |
taste_request_release_snapshot | Take the pictures of a release that has none (for example one published before snapshots existed, or whose snapshot was blocked). Free. Idempotent: returns the existing snapshot or the run already taking it. The release itself never changes; the pictures are attached to it as evidence. | Draft |
Releases and review
| Tool | What it does | Kind |
|---|---|---|
taste_diff_releases | Compare a release with a base release (default: the latest approved release before it). | Read |
taste_get_release | Get an immutable design release: contract payload, digest and materialized content. | Read |
taste_get_release_draft | Summarize the current draft that a release candidate would capture. Pass `surface_id` to preview a release for that surface (whether publishing would reuse an existing release depends on it). | Read |
taste_list_approvals | List approval decisions for a project or a specific target. | Read |
taste_list_releases | List design releases for a project, newest first. | Read |
taste_list_review_requests | List review requests for a project or release. | Read |
taste_prepare_release_candidate | Capture the selected draft objects at an expected domain revision as an immutable, digest-bound release candidate. Pass `surface_id` to prepare it for one surface: the release records that surface and the brand layers it resolves (with their revisions) at creation. | Draft |
taste_request_review | Ask workspace reviewers to decide on a release candidate. | Draft |
Component previews
| Tool | What it does | Kind |
|---|---|---|
taste_get_component_previews | Latest rendered previews of one repository component (by source path and export name) from rendered audits: status, screenshots (light and dark), the props used and the commit. Isolated renders from a Storybook story or the component harness; never app-route coverage. | Read |
taste_start_component_previews | Preview components that a commit's preview has not drawn yet (each preview run draws a limited number, components with no picture or changed code first, then the most used). Starts a rendered run at the same commit, in a qualified isolated sandbox, limited to `component_ids` (harness entry ids from the preview's rows with status not_attempted, at most 200); its pictures are added to that preview, never replacing it. Costs 2 usage units for up to 20 components and 1 more per further 20 (settled by the components actually drawn). Asking again for components already being previewed returns that run with `reused: true`. | Draft |
Repo profile
| Tool | What it does | Kind |
|---|---|---|
taste_get_build_scope | The files a build plan should start from, derived from the repository scan: the token files M1rror can rewrite, the folders holding the scanned components and screens (within the stored app root), each with why. On a repository with nothing found it returns common locations labelled as a guess. Read only; pass the result to taste_prepare_implementation as allowed_paths. | Read |
taste_get_repository_capabilities | What M1rror can do for a connected repository, before any paid run: the detected framework, styling and token files, and for each capability (map tokens, find components, build and verify with which checks, open a pull request) whether it works here and why, plus what is not supported. Read from git at the tracked branch head and the last scan; nothing is executed and no units are used. | Read |
Repo toolchain
| Tool | What it does | Kind |
|---|---|---|
taste_get_repository_toolchain | Read the detected toolchain of a connected repository: package manager, Node version, workspace tool, the monorepo packages (with framework), the chosen package, the exact commands used as checks (typecheck, lint, tests, build) and the names of check environment variables (never their values). | Read |
Repositories and scans
| Tool | What it does | Kind |
|---|---|---|
taste_get_repository_inventory | Get the static inventory of a repository at its latest audited commit. An agent with no `section` gets a summary (counts per section, framework, scan stats and `coverage`: how many files the scan read of how many, and which folders it skipped when it stopped at its budget), not the whole snapshot, which can be hundreds of thousands of characters; pass `section` (and `offset` / `limit`) to read one list at a time. | Read |
taste_list_audits | List audit runs for a project. | Read |
taste_list_component_bindings | List components with their code binding and binding status (bound, uncertain, unbound, stale). | Read |
taste_list_findings | List design-audit findings with evidence (file:line), severity and confidence. | Read |
taste_list_repositories | List repositories connected to a project with their head SHA and latest audit. | Read |
taste_list_scan_history | List scans (audits) of a repository's tracked branch, newest first, with date, commit, branch and status, to read findings from an earlier scan. | Read |
taste_start_audit | Start a design audit of a connected repository pinned to a commit SHA. `static` reads source without running it; `rendered` also renders components in a qualified isolated sandbox — the Storybook when there is one, otherwise each component in isolation through the zero-config harness — and reports rendered coverage. `app_root` optionally picks the app package of a monorepo for the harness. A commit that already has a scan (or preview) is not run again: the existing run is returned with `reused: true`. To run it again on purpose (the app uses live data or animation, a scan looked wrong), pass `rerun: { reason }`: it needs the same permission, uses the same units (disclosed in the run timeline, within the plan, kill switches and gates), is recorded in the audit log with the reason and never deletes the earlier result. The newest result is the one shown; earlier ones stay listed. | Draft |
Review links
| Tool | What it does | Kind |
|---|---|---|
taste_get_review_policy | The project policy for stakeholder approvals: advisory (default) or required from named stakeholders. | Read |
Runs
| Tool | What it does | Kind |
|---|---|---|
taste_cancel_run | Cancel a queued or active run. | Draft |
taste_get_run_status | Get the current status, budget and result of a run. | Read |
taste_list_run_events | List run events after a sequence number. | Read |
taste_list_runs | List recent runs for the workspace or a project. | Read |
taste_wait_for_run | Wait until a run finishes (completed, blocked, failed, cancelled or budget_exhausted), for up to timeout_s seconds (at most 50). Returns the run status with done: true when it finished, or the current status with done: false when the time ran out; call it again to keep waiting. | Read |
Screen accessibility
| Tool | What it does | Kind |
|---|---|---|
taste_get_screen_accessibility | The latest accessibility check of a screen (axe-core findings with rule, impact, element and help URL; what needs a person; what was not checked) and any check running now. `check: null` means the screen was never checked. | Read |
taste_run_screen_accessibility_check | Run axe-core against one screen as M1rror’s preview draws it (latest save, at a device size, state and theme), in a free run. Findings (rule, impact, element, help URL) are stored as evidence on the screen; read them with taste_get_screen_accessibility. Page-level rules decided by the preview page are not run. Idempotent: a check already running for the screen is returned. | Draft |
Screen exports
| Tool | What it does | Kind |
|---|---|---|
taste_get_screen_export | Where a screen or flow export stands: queued or drawing (with progress), or done with each file (format, size, download URL) and what could not be drawn. SVG files are raster pictures in an SVG wrapper (`raster: true`). | Read |
taste_list_screen_exports | The project's recent screen and flow exports, newest first (at most 20), optionally only those of one screen (`screen_id`) or flow (`flow_id`). | Read |
taste_start_screen_export | Export one screen (`target: { kind: 'screen', screen_id }`) or a whole flow (`target: { kind: 'flow', flow_id }`: its start screen and every screen its links reach, up to 20) as PNG, SVG and/or PDF, drawn from the latest save by M1rror's preview renderer at a device size (mobile, tablet, desktop), state and theme. A free run; poll taste_get_screen_export for the files. PDF is printed by the browser (vector text where it keeps it; a flow is one PDF, a page per screen). SVG is the PNG inside an SVG wrapper, not a vector drawing. Idempotent: the same request while one runs returns that run. | Draft |
Screen flows
| Tool | What it does | Kind |
|---|---|---|
taste_create_screen_flow | Name a flow through the screens and the screen it starts on (Preview plays it from there). The links between screens are the layers' actions (taste_update_screen); this only names the flow and its start. | Draft |
taste_get_screen_flow | The flow between a project's screens: every screen, the links between them (from the `action`s on their layers: navigate and open_overlay), back and web-address links, broken links (the target screen was deleted), and the named flows with their start screens. Set links with taste_update_screen. | Read |
taste_update_screen_flow | Rename a flow or change the screen it starts on (the screen must be one of this project's). | Draft |
Screen variants
| Tool | What it does | Kind |
|---|---|---|
taste_create_screen_variant | Make a design-time variant of a screen: a draft copy of its saved name, route, spec, states, surface and platform preset, linked to the original under a short name unique in the group (e.g. "B", "Empty", "Dense"). Copy from any member (screen_id); the new variant always belongs to the original’s group. Edit it with taste_update_screen. Releases are never changed. | Draft |
taste_list_platform_presets | List the platform presets a screen can be designed to (iPhone, iPad, Android phone and tablet, macOS and Windows windows, responsive web, email): device frames, safe areas, app bars and platform conventions, with the default preset of each surface platform. | Read |
taste_list_screen_variants | List a screen’s design-time variants: the original screen and every variant made from it (any member’s id works), each with its spec and platform preset, and which one is chosen (chosen_id, null: none yet). Variants compare designs side by side; nothing is split between real users. | Read |
taste_set_chosen_screen_variant | Mark which member of a screen’s variant group is chosen (the original or a variant; null clears it). Records the design decision only: no screen content changes and no release is touched. | Draft |
taste_set_screen_platform_preset | Set the platform preset a screen is designed to (taste_list_platform_presets), or null to use its surface’s default. Changes the frame and safe areas it is previewed in; the spec is not changed. A draft edit. | Draft |
Ship ledger
| Tool | What it does | Kind |
|---|---|---|
taste_get_implementation_brief | What to implement from the latest approved release (never a draft): unshipped items with CSS variable names and known files, scope, checks, the PR reference line and the tools to report back with. Several repositories: pass repository_id. | Read |
taste_get_ship_ledger | Approved vs shipped for an approved release: each approved token, component, screen and state change with its status (approved, implemented, verified by a check M1rror ran, merged; agent-only passes: reported_by_agent), its PR and commit, and coverage. | Read |
taste_link_pull_request | Declare a GitHub pull request as implementing an approved release, so the ship ledger counts what its diff changes. Idempotent per release and PR. M1rror then reads the PR (state, head, changed files) through its App. | Draft |
taste_submit_implementation_progress | Report progress on ledger items in a linked PR: in_progress or done, with the files you changed. A "done" counts as implemented only when those files are in the PR diff M1rror read. | Draft |
Store listings
| Tool | What it does | Kind |
|---|---|---|
taste_get_store_apps | The App Store and Google Play apps a project is linked to, with each store’s connection status. | Read |
taste_get_store_asc_handoff | Commands for uploading a screenshot set with the open-source App Store Connect CLI (asc) on your own machine: install, sign in (placeholders, never credentials), resolved app/version/localization ids and one upload command per language and device. | Read |
taste_get_store_listing | Store listing copy per language (name, subtitle, description, keywords, promotional text, what’s new, short description) with each store’s limits and locale codes. | Read |
taste_list_store_publish_runs | Recent store publishing runs for a project with status, progress and per-file or per-language results. | Read |
taste_plan_store_screenshots | Check a screenshot set against its store before publishing: connection, app link, editable version, languages, devices, limits and the usage units it would take. Sends nothing. | Read |
taste_set_launch_targets | Say where the product ships (web, ios, android). Ship shows app store screenshots and listing only for iOS and Android. | Draft |
taste_update_store_listing | Edit the source-language store listing copy. Each field is checked against the store limit; an empty field clears it. Translations are made in Ship → Languages. | Draft |
Store screenshots
| Tool | What it does | Kind |
|---|---|---|
taste_add_screenshot_slide | Add a slide to a screenshot set: an image (a reference, a stored app-capture screenshot or a generated image of this project) and a caption/subtitle in the source language. Needs expected_revision. | Draft |
taste_check_screenshot_set | Check every slide × device × language of a screenshot set without rendering pixels: text fitting (shrink/truncation), translation fallbacks, contrast, fonts, and whether every image may be published. Use before export or store upload. | Read |
taste_create_screenshot_set | Create a store screenshot set for iOS (App Store) or Android (Google Play). The template starts from the project brand tokens; devices default to what the store requires and languages to the project languages. | Draft |
taste_duplicate_screenshot_set | Duplicate a screenshot set with its template, slides, captions and their translations. | Draft |
taste_get_screenshot_set | Get a store screenshot set: brand template (token references and resolved colours), ordered slides with captions and image rights, devices, languages and the brand tokens available to the template. | Read |
taste_list_screenshot_sets | List the store screenshot sets of a project, newest first (cursor pagination). | Read |
taste_list_screenshot_sources | List images that can go on a slide: references, stored app-capture screenshots, generated images or the project’s own screens (kind=screen: drawn live at the store size; released_version says whether the latest approved release has it), each with whether it may be shown in previews and whether it may be published to a store. | Read |
taste_list_store_devices | List the App Store and Google Play screenshot sizes M1rror renders: id, store display type (App Store Connect screenshotDisplayType / Play imageType), asc CLI device type, exact pixel size, per-locale maximum and the store requirement. | Read |
taste_prepare_screen_images | Draw the project screens on a set’s slides at every chosen store size and language (a free run on the preview renderer in a headless browser). Renders are kept per exact input, so only what changed is drawn again. Returns how many are ready, pending or failed (e.g. gated_capability when this server has no browser). | Draft |
taste_remove_screenshot_slide | Remove a slide (and its caption strings) from a screenshot set. Needs expected_revision. | Draft |
taste_reorder_screenshot_slides | Reorder the slides of a screenshot set: send every slide id once, in the new order. Needs expected_revision. | Draft |
taste_reset_screenshot_template | Reset a screenshot set’s template to the defaults derived from the current brand tokens. | Draft |
taste_update_screenshot_set | Rename a screenshot set, choose its device sizes and languages, or change its template (a partial template is merged: layout, background style/colours/angle, font, caption/subtitle colour, weight, size and alignment, device frame, image radius/shadow/bleed). Colours are {token: "color.path"} or {hex: "#rrggbb"}. Needs expected_revision. | Draft |
taste_update_screenshot_slide | Change a slide’s image or its caption/subtitle (source language; translations are made in Ship → Languages). Needs expected_revision. | Draft |
Surface consistency
| Tool | What it does | Kind |
|---|---|---|
taste_get_surface_consistency | Compare the surfaces of a project (its website, Android app, desktop app…): tokens whose values differ between surfaces (with the brand or override that set each value), tokens and components some surfaces have and others lack, components whose props differ between surfaces, and surfaces whose newest release was made with an older brand version than the newest. Computed only from saved data: a surface with nothing to compare is listed in `no_data` with the reason, never guessed. | Read |
Surfaces
| Tool | What it does | Kind |
|---|---|---|
taste_detect_surfaces | Propose surfaces for a repository: each app package with its platform (web, React Native, desktop, Android, iOS, Flutter, email, marketing site), shared UI packages and backend services (marked as not a UI). Read from git at the tracked branch head; nothing is executed, nothing is saved and no units are used. A proposal that is already a surface carries its `surface_id`. | Read |
taste_get_surface | One surface: its repository, app root, platform, channel and kind, and the newest scan of that app root (commit, components and screens found). `code_readable` is false for native Android, iOS and Flutter surfaces, whose code M1rror does not read yet. | Read |
taste_list_surfaces | The project's surfaces: the separate apps it ships (a website, an Android app, a desktop app, a partner portal), each a repository plus an app root, a platform and a channel, with the newest scan of that app root. `kind` is `app`, `shared` (a UI package apps import) or `service` (a backend package, not a UI). | Read |
Tokens and components
| Tool | What it does | Kind |
|---|---|---|
taste_add_image_to_screen | Place a picture from the project's References (an upload, an imported picture, or a generated image once it is saved there) on a screen as an image layer. Name it by reference_id, never a URL. Give alt text that says what the picture shows, or decorative: true when it only adds mood. It goes right after after_node, at the end of parent_node, or at the end of the screen. A draft edit like taste_update_screen: the version it replaces is kept in the screen history; pass expected_revision from taste_get_screen. | Draft |
taste_create_screen | Create a screen from primitives and registered component instances (read taste_get_screen_catalog first, with surface_id or platform_preset, and design to its platform preset). Pass platform_preset to choose one; omitted, the screen uses its surface’s default. A new draft screen: people review, edit or delete it; nothing is sent for review. | Draft |
taste_diff_tokens | Diff two token revisions: added, removed (breaking) and changed tokens, with the components affected. | Read |
taste_export_tokens | Compile the token set to CSS variables, a typed TS module, flat JSON, DTCG (with sync metadata for re-import), Markdown docs, or native targets: SwiftUI (swift), Android colors.xml/dimens.xml (android-colors, android-dimens) and Jetpack Compose (compose). Every non-default theme (Dark…) is in the code formats in their own way (CSS [data-theme] blocks and prefers-color-scheme, Tailwind darkMode, SwiftUI dynamic colours, Compose per-theme colour sets); a format that cannot hold a theme says so in `notes`. Native exports list every approximation and omitted token in `notes`. Icon formats (icons-json, icons-ts, icons-svg) export the icon library: every semantic icon with its Iconify id and SVG, plus collection licenses. With `surface_id`, exports that surface's resolved set (its brand's foundation and brands, then its own overrides; or the project system then its overrides); `layers=true` keeps the layer structure in DTCG. | Read |
taste_get_component | Get a component contract: actual props JSON Schema from its code binding (never inferred), variants, states with applicability, token dependencies, guidelines, source path and story ids. | Read |
taste_get_screen | Get a screen spec (component instance tree) and its state applicability decisions. agent_draft is a change by the design agent that a person has not accepted yet (null: none): the design agent builds its next change on agent_draft.spec; the screen itself stays as saved until a person accepts. platform names the platform preset the screen is designed to; variant_of and variant_name mark a design-time variant. | Read |
taste_get_screen_catalog | What a screen can contain: the team's own components (bound to code, with their real props schemas, listed first) and built-in primitives. Build screens from the team components marked `use_first` wherever one fits, with the props their schema allows; use primitives for layout and for anything no team component covers. Pass screen_id (or surface_id, or platform_preset) to get the platform preset to design to: its frame size, safe areas, app bars and platform conventions (iOS navigation and tab bars, Material top app bar and navigation bar, desktop window chrome, responsive breakpoints). Follow them. | Read |
taste_get_tokens | Get the project token set (DTCG 2025.10): the stored document, resolved values with alias chains, validation diagnostics, the WCAG contrast report and which components depend on each token. | Read |
taste_import_code_screen | Turn a screen found in the app's code into an editable screen: its route's layout rebuilt from the team's components with the props written in the code, and built-in blocks for plain HTML. Values computed at run time are not rebuilt; the result lists them. The code-only version is kept in the screen history. Refuses a screen already designed here unless replace is true. A draft edit: nothing is sent for review. | Draft |
taste_import_code_screens | Import every screen found in code that has not been designed here yet (or the listed ones) as editable screens, as taste_import_code_screen does for one. Screens already designed here are skipped, never replaced. | Draft |
taste_list_direction_impacts | List design directions with validity and the token changes each would make if applied to the current set. | Read |
taste_list_screen_versions | List the earlier versions of a screen, newest first: the revision, name, route, why it was replaced (edit, redrawn from a reading, or restore) and when. Restore one with taste_restore_screen_version. | Read |
taste_list_screens | List screens in the project. | Read |
taste_list_token_revisions | List token revisions, newest first. | Read |
taste_propose_change | Propose a token change as a reviewable direction (a partial DTCG overlay with rationale). It is validated against the current token set but changes nothing: a person applies or discards it in System studio. To bring in Figma variables, read them with the Figma MCP server, convert them to DTCG and pass the file URL as `source`. To suggest plain-language names or purposes, set `$extensions["com.m1rror"].label` and `$description` on existing tokens (keep their `$type` and `$value`); they are reviewed like any other change. | Draft |
taste_search_components | Search the project component registry by name or description, with binding status. | Read |
taste_update_screen | Edit a screen name, route, spec or state decisions (optimistic revision check: pass the revision from taste_get_screen as expected_revision). Build the spec from taste_get_screen_catalog. A draft edit: the version it replaces is kept in the screen history and can be restored; nothing is sent for review. When the edit answers a comment, pass its comment_thread_id so the history entry links back to the comment. From the design agent, the change is saved as the screen’s agent draft (agent_draft) for a person to accept or undo. | Draft |
taste_update_screen_state | Design one state of a screen (loading, empty, error, denied or session-expired) as its own layers, without touching Default. Leave out `layers` to start from the design-system template drawn from the screen itself (Loading: a skeleton that keeps the layout; Empty: a message and the main action; Error: a message and Try again; Denied and Session expired: an explanation and the next step), or pass layers built from taste_get_screen_catalog. Pass the revision from taste_get_screen as expected_revision. A draft: the person accepts or undoes it, and the version it replaces stays in History. When the change answers a comment, pass its comment_thread_id so the history entry links back to the comment. | Draft |
taste_validate_tokens | Validate a token document without saving it (diagnostics + contrast). | Read |
System studio
| Tool | What it does | Kind |
|---|---|---|
taste_get_direction_changes | The token-by-token changes a direction or suggestion would make to the current set, with before and after values and the components and screens affected. | Read |
taste_get_token_impact | Where one token is used: the components that reference it (directly or through aliases), the screens that place those components or name the token, and the tokens that follow it. Only recorded usage is reported. | Read |
taste_preview_token_change | Preview a partial DTCG overlay against the current token set without saving: before/after values, validation, contrast, and the components and screens it would affect. | Read |
Taste check
| Tool | What it does | Kind |
|---|---|---|
taste_get_taste_check | The latest taste check of the project (or check_id): every sign that the UI looks AI-made, with its pass, level (sign / hint / question), exact places (token path, screen element, or file:line at the scanned commit) and a concrete fix; whether it is out of date and why; what was and was not checked; signs a person kept on purpose; and whether the model judgment is available. Signs and fixes adapted from unslop (CC BY 4.0). | Read |
taste_propose_taste_fixes | Turn the token fixes of taste findings into one proposed direction (a reviewable change to design values). Nothing changes until a person applies the direction in System studio, and it reaches customers only through a release. Only findings whose fix kind is token_overlay can be proposed. | Draft |
taste_run_taste_check | Run the taste check now (free, deterministic, a few hundred milliseconds): the rules read the latest design values, up to 200 screens and the latest code scan of the tracked branch. When nothing changed since the latest check it is returned as is (reused: true). Changes nothing in the design. Several repositories: pass repository_id. | Draft |
Team review
| Tool | What it does | Kind |
|---|---|---|
taste_get_approval_policy | The workspace approval policy for design releases: how many people must approve, whether authors can approve their own, whether every screen needs a decision, and whether open comments block approval. | Read |
taste_get_release_review | Where a release stands under the approval policy it was sent with: approvals counted versus needed, each screen’s decisions, and what still blocks approval (with links). | Read |
Variations
| Tool | What it does | Kind |
|---|---|---|
taste_compare_branches | Compare two branches of the connected repository (default: the baseline with a variation) from their stored scans and previews: screens and components added, removed and changed (with reasons and whether their pictures differ), design tokens and issues. Includes the picture ids for side-by-side views. Several repositories: pass repository_id. | Read |
taste_get_visual_diff | Compare two preview pictures pixel by pixel on the server (for example a screen on the baseline and on a variation): the share of pixels that differ, the box around them and both sizes. The highlighted difference picture is at the same path with /image. | Read |
taste_link_direction_to_branch | Link a design direction to the code branch where it is explored (the baseline or a variation), so design explorations and code variations line up. Shown on both. Replaces an earlier link of that direction. | Draft |
taste_list_commit_results | Every scan and preview ever run for one commit of a connected repository, newest first: when, status, units, the app folder of a preview, and the reason when it was a deliberate re-run. The newest finished result of each kind is the one shown; earlier ones are kept. Use it to see the history behind "Up to date with <sha>". | Read |
taste_list_variations | List a repository's baseline branch and its variations (other branches kept as versions of the app): head commit, whether each is scanned and previewed (results are cached per commit), what changed compared with the baseline (screens, components, tokens, issues), linked directions and any pull request. Several repositories: pass repository_id. | Read |
taste_remove_variation | Stop keeping a branch as a variation. Its scans and previews stay stored (adding it again shows them at once); linked directions stay linked. Nothing on GitHub changes. | Draft |
taste_scan_variation | Scan the stored head of a variation (or the baseline) unless that commit already has a scan; a scanned commit gets its preview by the automatic-preview rules. Uses the scan units shown in the variation list. Does not fetch from GitHub (use the app or refresh for that). | Draft |
taste_unlink_direction_from_branch | Remove the link between a design direction and its code branch. | Draft |
Last updated
Edit this page on GitHub