Veto MCP server

Read from the package source without running it. The installed server may list more.

• veto_a11y_advisor

  Analyzes UI components (React, Vue, HTML) for accessibility (a11y) compliance (WCAG) and provides actionable fix recommendations.

• veto_adr

  Converts a veto_council_debate result into a MADR-format Architecture Decision Record (ADR). Writes to docs/decisions/NNNN-<slug>.md if project_dir is provided. Returns the ADR markdown content.

• veto_agent_plan

  Gets a domain-expert execution plan from a specific worker agent. Returns approach, ordered steps, checklist, patterns, and pitfalls for the task.

• veto_api_contract

  Analyzes API endpoints and generates/verifies API contracts (e.g. OpenAPI or TypeScript types) to ensure front/back compatibility.

• veto_audit_log

  Queryable log of every council verdict, decision, and session event. Filter by session, agent, verdict, or date. Essential for tracing what happened and why.

• veto_autosave_status

  Returns the current auto-save state: whether a context is cached, the threshold, the last auto-save time, and the session ID.

• veto_benchmark

  Compares two competing approaches by running a full council debate on each in parallel, then returns a structured winner analysis with verdict, confidence delta, warning counts, and council reasoning. Use when you have two valid options and want an unbiased council judgment before committing.

• veto_bundle_advisor

  Accepts a webpack-format stats JSON (`webpack --json`) → heaviest assets and modules and duplicated packages (computed), plus code-split and CDN-externalization suggestions.

• veto_call

  Invokes any Veto catalog tool by name with the given arguments. Use veto_find_tools first to discover the tool name and its argument schema.

• veto_changelog

  Generates a structured changelog from git commits since the last tag, grouped by conventional commit type (feat, fix, refactor, etc.). Pure local git — no external calls.

• veto_ci_gate

  CI/CD pipeline gate. Runs code review + security scan + secrets scan on a git diff and returns a structured pass/warn/fail verdict with exit code. Ready for GitHub Actions and GitLab CI.

• veto_clone_detector

  Scans the project for duplicated code blocks or structural clones. Returns grouped findings and refactoring suggestions.

• veto_code_reviewwrite action

  Runs the Code Reviewer agent on a single snippet or file you pass directly. Returns scored findings (complexity, error handling, magic numbers, nesting, dead code) with severity and fixes. Pass file_path to surface findings as VS Code inline diagnostics (squiggles). For reviewing changed files across a git diff, use veto_diff_review instead.

• veto_commit_message

  Generates a conventional-commit message from staged changes (git diff --cached). Returns type, scope, subject, and body following the Conventional Commits specification.

• veto_compose_agentswrite action

  Creates a custom meta-agent by composing existing agents into a specialized pipeline.

• veto_context_status

  Returns the context window usage for a saved session — tokens used, % of platform limit consumed, and whether to compress or hand off before the window fills.

• veto_continue

  Restores a saved session on any platform. TRIGGER: when the user types `veto_continue` (with or without a session id) or asks to resume/continue/restore a session, call THIS live MCP tool directly with that session_id — do NOT treat it as a task to perform by hand, and never read ~/.veto/veto.db or reconstruct the session yourself. Call this immediately after switching platforms — Veto returns the

• veto_council_debatewrite action

  Runs the Veto Council — 7 specialist agents debate your task and return a GREEN/YELLOW/RED/DEADLOCK verdict. For full LLM-backed analysis on any platform (Claude Code, Gemini CLI, Codex CLI) with no API keys: (1) call with task only → get instant deterministic result + llm_upgrade.debate_prompt; (2) reason as all 7 agents using the prompt, then call again with agent_responses → get the LLM-backed

• veto_dead_code

  Project-scope dead code detector: exported symbols no other project file references (package entry points counted as public API), runs of commented-out code, and TODO/FIXME markers — all found deterministically — plus an LLM judgement of which are safe to delete.

• veto_debt_register

  Analyzes code quality + git commit frequency to produce a ranked technical debt register. High-churn + low-quality files are highest priority. Returns a prioritized list with debt type, location, and suggested agent.

• veto_decisions

  Decision-drift enforcement: records architectural decisions as machine-checkable constraints, then flags diffs that violate them. AI assistants forget decisions and re-litigate them sessions later — record "we use Postgres" with forbidden_patterns ["mongoose", "mongodb"] once, and veto_diff_review / veto_ci_gate automatically fail any future diff that adds them. Actions: add (rule + forbidden_patt

• veto_delegate

  Delegates a subtask to a specialist agent and returns only a compact summary — not the full output. Use when orchestrating multi-step work and you need an agent's conclusion without polluting your context with verbose output. Mirrors the "boomerang" delegation pattern.

• veto_dep_advisor

  Reads package.json (using the installed or package-lock version of each dependency) or requirements.txt, queries OSV.dev (free, no key) for known vulnerabilities in those exact versions, and returns a risk-ranked upgrade plan with breaking-change flags.

• veto_dep_verify

  Dependency-hallucination guard: verifies proposed package names against the live registry (npm, PyPI, crates.io) BEFORE install. Checks existence, age, monthly downloads, version history, deprecation, and typo-distance from popular packages. Catches hallucinated names and slopsquatting/typosquat risks. Call this whenever an AI suggests installing a package you have not used before.

• veto_diagram

  Generates a Mermaid architecture diagram of the project. Returns diagram text ready to paste into GitHub, Notion, or any Mermaid renderer.

• veto_diff_review

  Reviews a git diff — runs code review, security scan, and secrets scan in parallel across all changed files. Returns a structured verdict (pass/warn/fail), per-file findings, and a CI-ready summary. Pass diff directly or let Veto read it from project_dir automatically.

• veto_discover

  Scans a project directory and builds a rich context map: git state, tech stack, file structure, dependencies, and key config files. Stores the result in Veto memory so agents always have accurate project context. Call this once per project or after major structural changes.

• veto_doc_gen

  Reads a source file and generates JSDoc/TSDoc/docstring comments for all public APIs. Returns the annotated file content.

• veto_docs_fetch

  Fetches current, version-accurate documentation for any npm, PyPI, or crates.io package and returns it for injection into agent context. Eliminates hallucinated APIs. Results are cached for 24 hours.

• veto_drift_check

  Compounding-error checkpoint: queries the session's tool execution trace to detect loop indicators (consecutive failures, duplicate errors, tool repetition) and calls the debugger agent to formulate a concrete loop-breaker remediation plan.

• veto_env_setup

  Finds the environment variables the code actually reads and the project's config files, then generates a .env.example and a step-by-step setup guide. With write_files it writes .env.example — never over an existing one unless overwrite is true.

• veto_execute_parallelwrite action

  Runs multiple worker agents simultaneously via Promise.all. Use to get domain expert input from several agents in one round-trip — e.g. coder + tester + security-scanner all planning the same feature together.

• veto_explain

  Explains a file or raw text. Pass file_path to explain a source file (read by Veto), or text to explain an error message, stack trace, or compiler output. Files go to the coder specialist, raw text to the debugger specialist.

• veto_find_tools

  Searches the full Veto catalog (93 tools: agents, reviews, advisors, generators, memory, learning, git, workflow) by keyword and returns matching tool schemas. Compact mode exposes only core tools up front — call this first to discover the right tool, then invoke it via veto_call.

• veto_flag_auditor

  SDK-agnostic feature flag auditor — detects LaunchDarkly/Unleash SDK calls AND custom if(flags.X) patterns. Classifies flags as: actively toggled / candidate for removal / orphaned.

• veto_full_review

  Full pre-ship review: runs code review + security scan + secrets scan + quality analysis in parallel, then returns a combined verdict (pass/warn/fail). Use before any merge or deploy when you want richer output than veto_diff_review alone.

• veto_git_blame

  Returns ownership and contribution history for a file or directory — total commits, contributor list with commit counts, and last-modified metadata. Uses local git history: instant, zero network.

• veto_handoff

  Saves the current session and returns step-by-step instructions to continue on another AI platform (Gemini or Codex). TRIGGER: when the user types `veto_handoff` or asks to hand off / save-and-switch, call THIS live MCP tool directly — do NOT write a node script or touch ~/.veto/veto.db by hand. Call this when Claude is approaching its rate limit. The receiving platform calls veto_continue to rest

• veto_health

  Returns a live health snapshot of the Veto server — DB size, session/memory/pattern counts, uptime, error count, and average council latency.

• veto_hitl_checkpoint

  Pauses an agentic workflow and returns a structured approval-request the host AI surfaces to the user. The user's reply in the AI conversation provides the approval signal. Use before destructive operations, RED council verdicts, or bulk deletes.

• veto_learning_apply

  Applies learned tier thresholds to the router based on recorded task outcomes. Requires at least 20 recorded outcomes. The router immediately uses the new thresholds on the next veto_route_task call.

• veto_learning_stats

  Returns the self-learning router dashboard: tier distribution, per-agent quality stats, suggested threshold adjustments, and council insights. Use to understand how the router is performing and where to improve.

• veto_lint_rules

  Reads the project's existing lint/format configs and returns a complete ESLint/Prettier/Ruff/Biome configuration matching its conventions. Returns the file content; it does not write it.

• veto_local_llm

  Routes a task to a local LLM (via Ollama or LM Studio) instead of a cloud provider. Useful for privacy-sensitive data or simple, repetitive tasks.

• veto_memory_deletewrite action

  Deletes a knowledge entry by ID. Use to remove stale or duplicate entries found via veto_memory_search.

• veto_memory_export

  Exports all local memory (sessions, knowledge, patterns, decisions, project maps) to a portable JSON or Markdown file. Use markdown for a human-readable VETO_MEMORY.md file.

• veto_memory_import

  Imports memory from a JSON file exported by veto_memory_export on another machine. Merges into local SQLite using INSERT OR IGNORE — existing local rows are never overwritten. Call veto_sessions_list after import to confirm sessions arrived.

• veto_memory_search

  Searches the local knowledge base for entries matching a query. Call at the start of every task to find prior solutions before solving from scratch.

• veto_memory_store

  Stores a knowledge entry (solution, pattern, error, reference, or decision) in the local knowledge base for retrieval across sessions. Search before storing to avoid duplicates.

• veto_merge_conflict

  Analyzes a file with git conflict markers and returns a semantically correct resolution by understanding the intent of both branches.

• veto_metrics

  Returns a usage dashboard for the current Veto installation — sessions saved, council debates, quality trend, most-used agents, and knowledge base stats. Zero cost: pure SQLite reads. Great for a weekly health check.

• veto_new_feature

  New feature planning pipeline: council governance → execution plan → task DAG, in sequence. Collapses 3 manual tool calls into 1. RED council verdict stops the pipeline early — do not plan what is blocked. Returns council verdict + agent plan + structured task list.

• veto_notify_idewrite action

  Sends a message to the client as an MCP log notification (action show_message or set_status); whether it is shown is up to the client. MCP gives a server no way to open files or change the client's UI, so open_file returns an error rather than pretending.

• veto_onboard

  Generates a complete new-developer onboarding guide: setup, architecture, key files, how to run tests, first PR checklist.

• veto_openapi_gen

  Reads Express/FastAPI/Hono/Fastify route files and generates an OpenAPI 3.1 spec YAML. Returns the spec as a string and optionally writes it to openapi.yaml.

• veto_pattern_store

  Stores or updates a coding pattern observed in the codebase. Patterns are keyed by category.pattern-name and confidence increases with repeated observation.

• veto_patterns_list

  Returns stored coding patterns. Filter by prefix to get patterns in a specific category (e.g. prefix="naming." for all naming conventions).

• veto_platform_setup

  Returns the exact MCP config and setup steps to connect a specific AI platform to this Veto server.

• veto_playwrightwrite action

  Writes a runnable Playwright test (TypeScript) for a browser scenario and says how to run it. Veto does not launch or drive a browser itself.

• veto_plugins

  Lists all custom agents loaded from ~/.veto/agents/. Drop a .js file there that exports plan(task, context?) to register a new agent available in veto_agent_plan and veto_execute_parallel.

• veto_postmortem

  Incident description + timeline → blameless postmortem with five-whys RCA, action items, and correlation with past council RED verdicts if available.

• veto_pr_description

  Generates a complete GitHub PR description (title, summary, change list, test plan, breaking changes) from git diff main...HEAD. Ready to paste into GitHub or post via veto_pr_post.

• veto_pr_postwrite action

  Posts veto_pr_review or veto_diff_review findings to a GitHub PR as one review whose body lists every finding with its location. Requires GITHUB_TOKEN environment variable. Returns the review URL.

• veto_pr_review

  Fetches a GitHub PR diff and runs the full Veto triple-scan (code review + security + secrets). Returns a structured verdict and ready-to-post GitHub review comments. Set GITHUB_TOKEN env var for private repos.

• veto_pre_commit

  Pre-commit gate: runs secrets scan (hard block on any finding) + code review in parallel on staged changes. Faster than veto_full_review — tuned for commit-time validation. Returns a blocked/warn/pass verdict.

• veto_project_map_get

  Returns the stored project structure map for a directory. Use to navigate the codebase without scanning the filesystem.

• veto_project_map_updatewrite action

  Updates the project structure map for a directory. Call after creating, deleting, or moving files. The map enables fast codebase navigation without filesystem scans.

• veto_prompt_optimizer

  Scores a prompt for failure modes (vague role, missing output format, injection-prone, no examples) and returns a rewritten version with improvements. Zero API keys needed — uses the local agent loop.

• veto_query_advisor

  Accepts a SQL query or EXPLAIN ANALYZE output + optional schema → returns rewrite suggestions, CREATE INDEX statements, N+1 detection, and index risk assessment.

• veto_rate_status

  Returns current request counts and rate limit status for all AI platforms tracked by Veto.

• veto_rca

  Stack trace or error description → structured root-cause hypothesis with likely introducing commit. Reads the code at the stack trace's file:line locations and the recent git log, then runs debugger analysis.

• veto_record_outcome

  Records a task outcome (quality score) to feed the self-learning router. Call after completing any task. The router auto-applies learned tier thresholds every 20 recorded outcomes (disable via config auto_apply_learning=false); veto_learning_apply forces an update on demand.

• veto_release_notes

  Generates user-facing release notes from merged commits since the last git tag. Rewrites dev-speak into plain English (fix: race condition → Login is now more reliable).

• veto_route_task

  Scores a task for complexity (0-100) and returns the optimal tier, model recommendation, and rate status. Use before any substantial task to let the router decide which model to use.

• veto_sdd_agent

  Spec-Driven Development agent. Provides full SDD loop: spec validation, acceptance criteria generation, and BDD scenario authoring.

• veto_secrets_scan

  Scans text or code for exposed credentials — API keys, tokens, passwords, connection strings, private keys. Returns findings with masked values and line numbers. Pass file_path to surface findings as VS Code inline diagnostics.

• veto_security_scanwrite action

  Runs the Security Scanner (OWASP Top 10) on provided code. Returns vulnerabilities with severity, CWE/OWASP category, and remediation steps. Pass file_path to surface findings as VS Code inline diagnostics.

• veto_semantic_search

  Code search for natural-language questions (e.g. "where is user authentication handled?"). Veto ranks project lines by the query's keywords — lexical, not a vector index — and returns the ranked matches; the calling AI reads them to answer.

• veto_session_replay

  Two modes. (1) Event trace: pass session_id for the chronological tool-call timeline of a past session. (2) Transcript recall (opt-in capture): pass `query` to search your archived host transcripts (project-lifetime, keyword + local semantic) — returns a table-of-contents plus ranked, sentence-sized snippets; when a snippet is not enough, pass `expand` ({event_id} or {source_session_id|archive_id,

• veto_session_restore

  Restores the saved context snapshot of a previous session by ID so you can resume work where it left off. Use veto_sessions_list to find IDs. For the chronological event timeline instead of the working context, use veto_session_replay.

• veto_session_save

  Saves the current session context to SQLite. TRIGGER: when the user types `veto_session_save` / `veto_save_session` / `save session`, call THIS live MCP tool directly — never write a node script or INSERT into ~/.veto/veto.db by hand (that bypasses project scoping and corrupts state). Set auto_summarize: true to have Veto read the full conversation and generate an accurate structured summary itsel

• veto_sessions_list

  Lists the most recent saved sessions. Use query to search by summary, context, tags, or project path.

• veto_snapshot

  Returns the whole Veto state an editor HUD / statusline needs in ONE read-only call: latest session, latest council verdict, top learned patterns, per-platform rate usage, memory count, and health. Same shape the CLI statusline composes — built for veto-vscode and other editor integrations.

• veto_sre_advisor

  Calculates SLO error budget status (remaining %, projected exhaustion) and returns ranked reliability improvements. Error budget math is deterministic; prioritization uses the local agent loop.

• veto_status

  Returns Veto server status, version, and database info. Pass token_count to trigger auto-save if context usage crosses 70%.

• veto_summarize

  Generates a concise expert briefing of a project, directory, or file. Use at the start of a session to orient yourself on unfamiliar code. Returns bullet-point summary, key components, tech stack, and entry points. Faster and higher-level than veto_explain.

• veto_task_parse

  Parses a plain-English project description or PRD into a structured task DAG with dependencies, complexity scores, priorities, and suggested agent assignments. Feeds directly into veto_workflow.

• veto_test_gaps

  Reads a coverage report (lcov/JSON) or scans source files to identify untested paths and suggests concrete test cases.

• veto_translate

  Translates text or structured i18n files (JSON/YAML) to target languages while preserving variables and formatting.

• veto_type_coverage

  Counts explicit `any`, `as any`, @ts-ignore and @ts-expect-error in a TypeScript project and reports the tsconfig strict/noImplicitAny settings (computed), then suggests specific replacement types, security-sensitive paths first. Implicit any needs the compiler and is not counted.

• veto_usage_status

  Live AI usage dashboard. Shows tokens consumed today, requests per platform, subscription vs API usage split, 7-day history, and warnings when approaching limits.

• veto_watch

  Starts a file watcher on a project directory. Returns a watch_id. Call veto_watch_poll to collect file-change events with recommended agents. Call veto_watch_stop when done.

• veto_watch_poll

  Polls for file-change events from an active watcher. Returns accumulated events since last poll (events are cleared on read). Each event includes the file, recommended agent, and suggested veto tool to call.

• veto_watch_stop

  Stops an active file watcher.

• veto_workflowwrite action

  Runs a sequential agent pipeline with optional pass/fail gates between steps. Each step runs a worker agent; if a gate score is set and the step confidence falls below it, the pipeline stops. Returns per-step results plus an overall verdict (passed/partial/failed).

• Code scan380 source files scanned8/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitylocal package, no credentials required12/15
• Maintenancelast push 2 days ago15/15
• Maintainer identityregistry namespace matches repository owner6/10

Safety score

63/100

higher than 18% of 48,255 servers

Tools

95

the typical server has 7

Tools that change things

12%

typical: 0%. Fewer write tools means less an agent can break

GitHub stars

4

more than 82% of 28,688 servers

Downloads a week

354

more than 83% of 12,191 servers with a package

Veto: common questions

Is Veto MCP server safe?

With care: it is graded C, so read the findings first (63/100). Read the Veto safety report

How do I install Veto?

It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.

Does Veto need an API key?

Not as far as the registry entry and our scan can tell: no credentials are declared or required.

Is Veto maintained?

The last commit was 22 days ago (2026-10-13). The latest release is v3.9.0.

How does Veto compare with other MCP servers?

safety score 63/100 (higher than 18% of 48,255 servers); tools 95 (the typical server has 7); tools that change things 12% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.