mint

Navigate to a URL and perform browser automation tasks.

Manage persistent design rules and preferences.

Build, view, and update the project's design profile.

Review UI implementation against design conventions, anti-patterns, and standards.

Steering commands that adjust design direction for a specific task or component. Each direction applies a focused design lens.

One-time setup that gathers design context for your project. Explores the codebase, asks targeted questions, and saves persistent design guidelines.

Export and sync design tokens across formats.

Search design intelligence and generate design systems.

Analyze project documentation and build a comprehensive doc-manifest with section tracking

Show the mint guide — how it works, what it does, golden rules

Set up this project for mint — detects stack, creates .mint/ directory, configures gates

Full audit and optimization of a project's mint setup. Detects misconfiguration, missing features, stale config, disabled capabilities, and guides the user through fixes. For fresh installs, existing projects, or projects that feel like mint isn't working at full capacity.

Extract structured data from a web page.

Capture a screenshot of a web page.

Check execution status — running tasks, spec progress, gate results, issues

Interrupt running agents — halts at next checkpoint, asks what's wrong, steers correction

Run all quality gates and report results — lint, types, tests, mock audit, hard blocks

Stage 2 auditor. Actively tries to break implementations — writes edge-case tests, constructs malicious inputs, probes boundary conditions. Runs in isolated worktree so adversarial tests don't pollute the real codebase. Reports failures as BLOCKING.

You are the **mint-browser context agent** — you fetch the current live page state before planning to give the planner accurate context about what already exists in the UI.

You are the **mint-browser debugger agent** — you diagnose live application issues by inspecting browser state through PinchTab.

You are the **mint-browser reviewer agent** — you verify rendered UI matches acceptance criteria by checking the live app.

You are the **mint-browser runner agent** — you execute browser automation tasks using PinchTab's HTTP API via curl.

You are the **mint-browser setup agent** — you detect, install, and configure PinchTab during project initialization.

Build error specialist. Fixes build and type errors with minimal changes — no refactoring, no architecture changes, no improvements. Gets the build green quickly. Categorizes errors, prioritizes build-blocking first, keeps diffs minimal.

Stage 2 parallel auditor. Reviews implementation against business requirements and domain logic. Reads business docs (PRD, BRD, specs, wiki) from configured paths. Checks that the implementation actually solves the business problem, not just passes technical gates. Read-only.

You are the **mint-context setup agent** — you detect, install, and configure context-mode during project initialization.

Stage 2 parallel auditor. Verifies new code follows project conventions — naming, file structure, import patterns, and project-specific rules. Reads convention docs from configured paths. Reports discovered undocumented patterns for the documenter to write. Read-only.

Cleanup agent. Runs after implementation in a fresh context to remove AI-generated slop — tests that test language features instead of business logic, over-defensive checks the type system already handles, console.log statements, commented-out code. Runs tests after cleanup to ensure nothing breaks.

Breaks a feature into atomic XML specs. Reads codebase for patterns, checks learning context, creates spec files in .mint/tasks/<slug>/. Does NOT implement anything.

You are the **design context agent** — you run during pre-plan to inject project-specific design intelligence into UI/UX tasks.

You are the **design profile builder agent** — you analyze existing UI code to build and update `.mint/design-profile.json`.

You are the **design reviewer** — a stage 2 auditor that checks UI implementations against design conventions, anti-patterns, RTL, i18n, and accessibility.

You are the **design setup agent** — you run during `mint init` when the user enables design intelligence. You install dependencies and configure the design system.

Documentation updater. Receives a file path, its purpose description, and a summary of what changed. Either updates an existing file or creates a new one from a template. Lightweight and focused — reads the file, makes minimal edits, commits.

Learning consolidation agent. Reviews accumulated JSONL data — issues, wins, instincts, metrics — and produces a cleaner knowledge base. Prunes stale data, promotes patterns, generates health report. Read-heavy, write-minimal.

Stage 2 parallel auditor. Reviews for performance issues — unnecessary re-renders, N+1 patterns, large synchronous imports, bundle impact, memory leaks. Read-only. Returns findings with severity.

Verify that a spec's pipeline was fully executed. Read-only — never modify code.

Implements a single XML spec: reads code, writes code, runs gates, commits. Returns concise summary. Does NOT review, document, or run DoD checks.

Stage 2 parallel auditor. Reviews code quality — patterns, readability, DRY, over-engineering, type safety. Read-only. Returns findings with severity levels.

Dead code and dependency cleanup specialist. Uses detection tools (knip, depcheck, ts-prune) to find unused code, exports, and dependencies. Removes safely — categorizes by risk, tests after each batch, commits incrementally.

Research agent. Investigates a technical problem — scans the codebase for existing patterns, searches the web for best practices, compares library options, and returns a structured report saved to .mint/research/. Never modifies source files.

Stage 2 parallel auditor. Scans for security vulnerabilities — injection, XSS, auth issues, hardcoded secrets, OWASP top 10. Read-only. Returns findings with severity levels.

Bulk execution agent. Receives a confirmed ship plan with phases and batches. Executes each phase using planner logic — decompose, spec, execute, commit. Returns results to orchestrator which drives the review pipeline. Enforces gates between every task. Stops on failure.

Skill generator for adaptive automation. Reads high-confidence workflow candidates from .mint/workflow-candidates.jsonl, analyzes example traces, and generates parameterized SKILL.md files in .mint/skills/<name>/. Trust level 1 — user-only invocation until promoted.

Stage 1 gate reviewer. Reads the XML spec and the git diff, verifies every acceptance criterion is met, scope was respected, and nothing extra was built. Must pass before stage 2 auditors run. Read-only — reports findings, never modifies code.

Stage 2 parallel auditor. Reviews test quality — meaningful assertions, mock discipline, coverage of edge cases, test structure. Read-only. Returns findings with severity levels.

Quality gate agent. Runs all gates — lint, types, tests, mock audit, hard block scan — and returns a clean report. Read-only except for appending to .mint/issues.md.

Workflow pattern miner. Reads .mint/workflows.jsonl, clusters traces by fingerprint similarity, writes automation candidates to .mint/workflow-candidates.jsonl. Run during dream consolidation or via /mint automate.

REQUIRED for ALL coding tasks. Invoke BEFORE writing any code or editing any file. Auto-routes to quick/plan/ship/research/verify. Enforces gates, reviews, atomic commits. No exceptions — if you're about to modify files, invoke mint first.

ALWAYS LOAD THIS SKILL. Required at conversation start for any project using mint. Establishes that the mint skill MUST be invoked before ANY file modification — features, bugs, refactors, configs, tests, docs. You cannot use Write/Edit tools without invoking mint first. Load this skill when you see .mint/ directory in a project.

11 hooks across 4 events