Veto

MCP开发工具

提供方 jigyasudham

开发工具 未标注 API Key 社区 / 第三方 ClaudeCursorVS CodeWindsurf

93 agentic MCP tools + 49 specialist agents for every major AI CLI. Self-learning, no API keys.

一句话选型结论

按资料字段整理

Veto 属于开发工具类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude、Cursor、VS Code 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

mcpmcp serverai agents

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Veto当前 未标注 未标注 未标注 无 未标注
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方jigyasudham上游标注的维护方 jigyasudham
分类开发工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

89.3 KB
来自项目仓库与上游目录的原文,未做删改

veto

> 93 agentic tools. 49 specialists. Every major AI CLI. Self-learning. Zero extra cost on subscriptions.

An MCP server that runs locally on your machine, plugs into Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, Cursor, Windsurf, Zed, and JetBrains using your existing subscriptions — giving every AI a council of specialist agents, local LLM support, SDD agents, playwright automation, persistent cross-platform memory, a self-learning router that re-tunes its tier thresholds automatically every 20 recorded task outcomes (reviews record outcomes for you; configurable via auto_apply_learning), CI/CD gates, workspace discovery, and bidirectional IDE communication.

> Billing note: "Zero cost" applies to subscription plans (Claude Max, Gemini Advanced, etc.). If you are on API/pay-per-token billing, LLM reasoning done for Veto agents (via the agentic loop or MCP Sampling) counts toward your token usage like any other turn. veto init detects API key environment variables and warns you automatically.


Getting Started```bash

1. Install the CLI — puts the bare veto command on your PATH

npm i -g @jigyasudham/veto

2. Register Veto with every AI client you use (Claude Code, Gemini, Codex, Cursor, …)

veto init


Prefer not to install anything? Every command also works via npx:```bash
npx -y @jigyasudham/veto@latest init

The two are independent by design. veto init writes MCP configs that launch the server with npx -y --package @jigyasudham/veto@latest veto-server — npx re-resolves @latest against the registry on every client restart, so the MCP server auto-updates itself and a global copy can never pin it to an old version. The global install only provides the CLI (veto doctor, veto sessions, the statusline, …); keep it current with npm i -g @jigyasudham/veto@latest when veto doctor says it's behind.


How the Agents Work

No API keys, zero extra cost. Every worker agent is a deterministic expert module at its core, with two optional layers of LLM reasoning on top — all of it delegated to the AI you're already paying for.

Default — Deterministic expert modules

Out of the box, each of the 42 worker agents runs as a hand-written expert module (plan() / analyze() in src/agents/) — not an LLM. They always run, work offline, and cost zero tokens. Their depth varies by design: analysis agents (security scanner, secrets, dependency audit, clone detector, privacy, auth, performance, compatibility, …) apply real algorithms — regex/AST detection, OWASP/CWE rules, hash-based clone matching — while planning agents (coder, debugger, tester, …) are structured expert playbooks: curated steps, checklists, and pitfalls for the task category, built to be reasoned over by the AI you already pay for rather than to reason themselves.

Path A — Agentic loop (most clients: Claude Code, Cursor, Windsurf)

Veto returns the specialist's role, rubric, and an output contract as an llm_upgrade prompt. The host AI reasons as the specialist and passes structured JSON back to complete the operation. This is the primary path — it costs nothing beyond your existing subscription and works on every client.

Path B — MCP Sampling (clients that support server.createMessage)

Where Sampling is available, the same upgrade happens server-side without the extra round-trip. Note: the July 2026 MCP spec revision deprecates Sampling protocol-wide (12-month sunset), so the agentic loop (Path A) is Veto's long-term default; Sampling remains a transparent optimization where it exists.

The 7-agent Council is LLM-first — its value is the multi-agent debate — but it too falls back to a deterministic verdict when no LLM path is available. When multiple agents run, they execute in parallel.


Specialist Roles

49 specialists: 42 deterministic worker agents across 6 domains + a 7-agent Council. The Council debates trade-offs before you build; the worker agents do the hands-on analysis and planning. Each is a deterministic expert module that can upgrade to LLM reasoning — see How the Agents Work. List them anytime with veto agents.

Council (7)
Lead Dev · PM · Architect · UX · Devil's Advocate · Legal · Security

Development (12)
Coder · Code Reviewer · Tester · Debugger · Refactor · Database · API · Frontend · Backend · DevOps · Performance · Migration

Security (6)
Security Scanner · Auth Agent · Data Privacy · Secrets Agent · Dependency Audit · Penetration Tester

Memory (5)
Context Manager · Decision Logger · Project Mapper · Pattern Learner · Knowledge Base

Research (7)
Researcher · Tech Advisor · Cost Analyzer · Competitor Analyzer · Risk Assessor · Estimator · Ethics & Bias

Quality (5)
Code Quality · Documentation · Accessibility · Compatibility · Error Handling

Workflow (7)
Task Planner · Task Coordinator · File Manager · Git Agent · Search Agent · Reporter · Automation


MCP Tools (93)

Category Tools
Session veto_status · veto_session_save · veto_session_restore · veto_sessions_list · veto_autosave_status · veto_session_replay
Router veto_route_task · veto_rate_status
Council veto_council_debate · veto_benchmark · veto_adr
Agents veto_agent_plan · veto_execute_parallel · veto_explain · veto_compose_agents · veto_delegate
Review veto_code_review · veto_security_scan · veto_secrets_scan · veto_diff_review · veto_full_review · veto_pr_review
Pipelines veto_ci_gate · veto_pre_commit · veto_new_feature · veto_workflow · veto_task_parse
Advanced veto_local_llm · veto_semantic_search · veto_sdd_agent · veto_playwright · veto_notify_ide
Quality veto_clone_detector · veto_lint_rules · veto_api_contract · veto_a11y_advisor · veto_type_coverage · veto_test_gaps
Advisors veto_dep_advisor · veto_dep_verify · veto_query_advisor · veto_bundle_advisor · veto_dead_code · veto_hitl_checkpoint · veto_drift_check
Watching veto_watch · veto_watch_poll · veto_watch_stop
Memory veto_memory_store · veto_memory_search · veto_memory_delete · veto_decisions · veto_project_map_update · veto_project_map_get · veto_pattern_store · veto_patterns_list · veto_memory_export · veto_memory_import
Learning veto_record_outcome · veto_learning_stats · veto_learning_apply
Handoff veto_handoff · veto_continue · veto_platform_setup
Observability veto_usage_status · veto_audit_log · veto_health · veto_metrics · veto_snapshot
Discover veto_discover · veto_summarize · veto_git_blame · veto_changelog · veto_onboard · veto_debt_register
DevTools veto_docs_fetch · veto_context_status · veto_openapi_gen · veto_flag_auditor · veto_env_setup · veto_commit_message · veto_pr_description · veto_pr_post · veto_prompt_optimizer · veto_sre_advisor · veto_diagram · veto_rca · veto_doc_gen · veto_postmortem · veto_release_notes · veto_translate · veto_merge_conflict
Plugins veto_plugins

Compact Mode — 93 tools without the context tax

93 tool schemas cost a client ~20K context tokens before the user types a word. Compact mode advertises a surface that is 5–6× smaller: seven core tools (veto_status, veto_session_save, veto_session_restore, veto_route_task, veto_council_debate, veto_memory_search, veto_record_outcome) plus two meta-tools — veto_find_tools searches the full catalog by keyword and returns matching schemas on demand; veto_call invokes any catalog tool by name. Every tool remains directly callable in both modes; compact only changes what is advertised up front.

Enable it with VETO_COMPACT=1 in your MCP server config env, or "compact_tools": true in ~/.veto/config.json:```jsonc
{
"mcpServers": {
"veto": {
"command": "npx",
"args": ["-y", "--package", "@jigyasudham/veto@latest", "veto-server"],
"env": { "VETO_COMPACT": "1" }
}
}
}


## Dependency-Hallucination Guard

LLMs propose plausible-but-nonexistent package names, and adversaries register those names on public registries (slopsquatting) — a supply-chain attack class with no pre-install check in most AI workflows. `veto_dep_verify` checks every proposed package against the live registry **before** you install:```
veto_dep_verify { packages: ["axios", "axois", "left-padd"], ecosystem: "npm" }
→ axios      verified    (14 years old, 40M downloads/month)
→ axois      HIGH_RISK   (1 edit from "axios" — possible typosquat)
→ left-padd  NOT_FOUND   (likely hallucinated — do NOT retry the install later:
                          nonexistent AI-suggested names are prime slopsquat targets)

Signals per package: registry existence, age, monthly downloads, version history, deprecation, and typo-distance from popular packages. Supports npm, PyPI, and crates.io. Network failures return unverifiable — never silently safe.

Decision-Drift Enforcement

AI assistants forget architectural decisions and re-litigate them sessions later — the most common complaint about long-running AI projects. Veto's memory doesn't just store decisions; it enforces them. Record a decision once as a machine-checkable constraint:```
veto_decisions {
action: "add",
rule: "We use Postgres — no Mongo",
why: "Decided 2026-05: relational data, team expertise",
forbidden_patterns: ["mongoose", "mongodb"],
severity: "block"
}


From then on, `veto_diff_review` and `veto_ci_gate` automatically fail any diff whose **added lines** match a forbidden pattern — when an AI quietly adds `mongoose` to the imports three sessions later, the review fails with the rule and the rationale attached. Patterns are case-insensitive regexes (with substring fallback), optionally scoped to a file glob (`src/**/*.ts`), per-project or global, severity `block` or `warn`. Manage with `action: list / check / disable / enable`.

You don't have to remember to do this. When a council verdict (the LLM-backed one) or an ADR settles something, its result carries a one-time `constraint_invitation`: your AI asks you once whether it should become a rule, and passes your answer back as `add` or `decline` with the `invitation_id`. It never asks twice about the same verdict. `action: list` shows how many invitations were offered, accepted and declined; that count stays on your machine.

A rule can't stall your reviews. `add` refuses a pattern that could hang the check: one over 200 characters, or a repeated group that itself repeats, like `(a+)+`. Every check is also time-boxed, so a slow rule turns into a warning instead of blocking `veto_ci_gate`.

## Compounding-Error Circuit Breaker

Agents fail silently in loops — retrying the same broken call, re-hitting the same error, thrashing between two tools — and burn a whole session before anyone notices. `veto_drift_check` scans the recent tool-call trace for that pattern mid-flight and trips a breaker before the spiral compounds:```
veto_drift_check
→ DRIFT DETECTED
  • 4 consecutive failed calls (veto_diff_review)
  • same error repeated 3× ("no diff provided")
  • tool veto_route_task called 6× in a row
→ remediation (debugger agent): stop retrying; the diff is empty —
  point at a project_dir with uncommitted changes or pass `diff` explicitly.

It looks for three drift signals — consecutive failures, duplicate error messages, and single-tool repetition — and when any trips, it runs the debugger agent over the trace for a concrete recovery step instead of letting the loop continue. Call it as a periodic checkpoint in long agentic runs.

Which tool do I use?

Several tools overlap by design (different granularity or entry point). Quick guide:

Reviewing code

You have… Use Note
A snippet or single file in hand veto_code_review not veto_diff_review, which reads a git diff
Uncommitted/changed files (git diff) veto_diff_review code + security + secrets scans in parallel
To gate a commit (hard-block on secrets) veto_pre_commit tuned for commit-time
To gate CI (exit code + pass/warn/fail) veto_ci_gate for GitHub Actions / GitLab CI
A deeper pre-merge/pre-ship pass (+ quality) veto_full_review richer than veto_diff_review
A GitHub PR by number/URL veto_pr_review fetches the diff, returns postable comments

Remembering things

Want to… Use
Save/recall a solution, decision, or reference veto_memory_store / veto_memory_search
Track a recurring code convention veto_pattern_store / veto_patterns_list
Navigate the codebase without scanning the filesystem veto_project_map_get (refresh via veto_project_map_update)

Running multi-step work

Want to… Use
Run several agents at once on one task veto_execute_parallel
Run a sequential pipeline with pass/fail gates veto_workflow
Turn a PRD / plain English into a task DAG veto_task_parse (feeds veto_workflow)
Plan a new feature end-to-end (council → plan → tasks) veto_new_feature

Sessions

Want to… Use
Resume work with full saved context veto_session_restore (or veto_continue for the latest)
See the event / tool-call timeline of a session veto_session_replay
Move work to another AI tool veto_handoff → veto_continue

MCP Resources

URI What it returns
veto://sessions All saved sessions across platforms
veto://project-map?dir= Stored project structure map
veto://memory?q= Knowledge base search results
veto://patterns Learned coding patterns

MCP Prompts

Prompt What it does
code-review Full code review — paste code, get scored findings
security-audit OWASP Top 10 scan with CWE references
deploy-checklist Council reviews your deployment plan before you ship
explain-file Expert explanation of any file, auto-routed by type

CLI Commands

These work standalone in any terminal — no AI client needed. The bare veto command comes from the global install (npm i -g @jigyasudham/veto, see Getting Started); without it, prefix any command with npx -y @jigyasudham/veto@latest.```bash
veto init # Register Veto with every AI app found + scan project
veto doctor # Per app: does it list Veto, does Veto start, has the app started it?
veto doctor --quick # Same, without launching the server to test it
veto doctor --fix # Also move aside old Veto guides left in Codex/Gemini files
veto status # Version, DB path, session/memory/outcome counts
veto version # Alias for veto status
veto sessions [words] # Newest 20 saved sessions, and how many exist ([auto] = auto-save)
veto sessions --all | --limit N # All of them, or N; add --json for machine output
veto sessions --clean # Remove auto-saves older than 7 days
veto continue <id> --as <client> # Restore a session from a terminal (8-character id prefix is enough) —
# the same code as veto_continue, for an app that did not load Veto
veto memory [query] # Search knowledge base (blank = all entries)
veto patterns [prefix] # List learned agent/routing patterns
veto tools [filter] # List all 93 MCP tools (--json for machine output)
veto agents [filter] # List all 49 specialists — workers + council (--json)
veto routing [status|log|reset] # Inspect the opt-in routing feedback loop
veto transcripts <sub> # Opt-in transcript capture (off by default) —
# enable|status|sources|list|show|purge|disable
veto lessons <sub> # Opt-in note sharing between your AIs (off by default) —
# on|status|list|why|forget|flows|off|exclude|include|alias|recheck
veto statusline <sub> # Veto line under the Claude Code prompt, or beside
# Codex/Gemini — install|status|print|watch|uninstall
veto api <command> # JSON for editor extensions — version|snapshot|recall search|
# recall expand|diagnostics (see "For editor extensions" below)
veto hook install # Install pre-commit secrets scan hook
veto hook remove # Remove the veto pre-commit hook
veto check # Scan staged changes for secrets (used by hook)
veto help # Commands + MCP tools reference
veto help --troubleshoot # Full troubleshooting guide


### `veto doctor````
veto doctor

  Veto Doctor — system health check
  ─────────────────────────────────────────────────────
  ✓ Node.js v22.13.0 (this terminal)
  ✓ ~/.veto exists
  ✓ Database ~/.veto/veto.db
    17 sessions · 12 memories · 3 patterns

  AI apps — registration · launch test · last start
  ─────────────────────────────────────────────────────
  ✓ Claude Code — connected
      source: claude mcp list
      launch test: answered in 1.2 s — Veto 3.7.0, 93 tools
      last started by claude-code 2.1.0 3 h ago — Veto 3.7.0, Node v22.13.0
  ✗ Antigravity — Veto is only in ~/.gemini/antigravity-cli/mcp_config.json, a file Antigravity no longer reads
      fix: veto init   (then fully restart the app)
  · Gemini CLI — not installed

  Fallback guidance — what an AI is told when Veto did not load
  ─────────────────────────────────────────────────────
  ✓ ~/.claude/skills/veto/SKILL.md

  ⚠  1 issue found. Each has its fix above.

Every ✓ says what it rests on. Registration is what the app's own mcp list reports (or the file the app reads, when its CLI is not on PATH). The launch test runs the exact configured command and completes the MCP handshake, which catches npx failing to reach the registry and a server that exits on start. Last started comes from the server itself: each time an app starts Veto, it records which app, which Node, and whether SQLite loaded in that app's runtime (~/.veto/host-starts.json). That is the only check that sees a GUI app launching Veto with a different Node than your terminal. veto doctor exits with status 1 when it finds an issue, so scripts can rely on it.

When an AI's app did not load Veto, Veto's veto skill (written by veto init into Claude Code, Codex and Antigravity/Gemini skill folders) tells it to say so and use veto continue / veto sessions / veto doctor instead of reading Veto's database by hand.

Versions of veto init before this release wrote Veto's guide over ~/.gemini/GEMINI.md (Gemini's own memory file) and into ~/.codex/AGENTS.override.md, which Codex reads instead of your ~/.codex/AGENTS.md. Current versions never write either file. veto doctor reports any copy left behind, and veto doctor --fix (or veto init) renames a copy to *.veto-backup — only when the file is exactly a guide Veto shipped. A file with anything else in it, such as memories Gemini saved below the guide, is reported and never touched. What an old init overwrote cannot be recovered.

For editor extensions: veto api

An extension that shows Veto's state reads it through veto api, not by opening Veto's databases. Every response is one JSON envelope on stdout (contract, command, backend_version, state, and message / next_action whenever state is not ok). Its shape is versioned apart from Veto. Within contract 1, fields are only added, so ignore fields you do not know.

Command Request Returns
version — contract version, commands, the CLI's path, whether SQLite loads
snapshot { project, db? } capture state, archive counts for the project, lesson sharing and counts, the trial's progress. Read-only, and returns counts rather than paths
recall search { project, query, limit?, source?, db? } masked hits from that project's archived chats, and the matching chats' segments
recall expand { project, event_id } or { project, archive_id, segment_index } masked text of one turn or segment, only if it belongs to that project
diagnostics { checks?: [&quot;host_cli&quot;, &quot;probe&quot;], db? } veto doctor's per-app checks. The slow ones run only when named

Send the request as JSON on stdin, and start the CLI with an argument array and no shell: execFile(process.execPath, [cliPath, &#x27;api&#x27;, &#x27;recall&#x27;, &#x27;search&#x27;, &#x27;--stdin&#x27;]), where cliPath comes from veto api version. On Windows, veto is a .cmd shim that only a shell can start, and passing a search query through a shell turns it into a command line. A project is always required, and a db other than the one Veto uses is refused with db_mismatch rather than answered from the wrong database. Archives kept after capture is turned off can still be searched, and each response says what state capture is in. veto transcripts purge is what deletes them. The JSON Schemas and example responses ship in the package under contracts/api-v1/.

veto statusline

In Claude Code, veto statusline install adds a Veto line under the prompt: the latest council verdict, router confidence, live context and rate-limit use, and memory size. While note sharing is on, it also shows how many notes Veto holds (notes 178); with sharing off, that count is left out rather than shown as zero.

Codex and Gemini cannot run a custom status line — each only shows its own built-in items (Codex: openai/codex#20244). So there, the same line runs in a small split pane beside the AI and follows its session in the current folder:```bash
veto statusline watch # follows whichever AI is working in this folder
veto statusline watch --client=codex # or pin one: claude | codex | gemini
veto statusline install --client=codex # prints the split-pane setup for your terminal; writes nothing


For Codex it reads context and rate-limit use from Codex&#x27;s own session file; Gemini records no usage figures, so its line shows the live session without gauges. `veto statusline print --client=codex` prints one line, for a tmux status bar or a script.

---

## Council Debate

Two-phase flow — works on Claude Code, Gemini CLI, Antigravity CLI, and Codex CLI with no API keys:```
# Phase 1 — call with task, get instant deterministic result + LLM upgrade prompt
veto_council_debate {
  task: &quot;migrate auth from sessions to JWTs&quot;,
  project_dir: &quot;/your/project&quot;,
  strictness: &quot;standard&quot;
}
→ {
    llm_backed: false,
    final_verdict: &quot;YELLOW&quot;,
    votes: { lead_dev: {...}, architect: {...}, security: {...}, ... },
    llm_upgrade: {
      available: true,
      instruction: &quot;Read debate_prompt, reason as all 7 agents, call again with agent_responses&quot;,
      debate_prompt: &quot;You are running a Veto Council debate. Analyze the task as each specialist...&quot;
    }
  }

# Phase 2 — reason as all 7 agents, pass responses back → get LLM-backed verdict
veto_council_debate {
  task: &quot;migrate auth from sessions to JWTs&quot;,
  agent_responses: {
    lead_dev:  { verdict: &quot;warn&quot;,    reason: &quot;Stateless JWTs complicate logout — need blocklist&quot;, concerns: [&quot;Refresh token rotation must be atomic&quot;], recommendation: &quot;Use short-lived access tokens (15m) + httpOnly refresh tokens&quot; },
    pm:        { verdict: &quot;approve&quot;, reason: &quot;JWT migration unblocks mobile clients&quot;, concerns: [], recommendation: &quot;Ship behind a feature flag, roll back if logout issues&quot; },
    architect: { verdict: &quot;approve&quot;, reason: &quot;Good fit for stateless microservice boundary&quot;, concerns: [&quot;Clock skew can break expiry across services&quot;], recommendation: &quot;Add NTP sync check; use relative expiry not absolute timestamps&quot; },
    ux:        { verdict: &quot;approve&quot;, reason: &quot;No user-visible change if migration is seamless&quot;, concerns: [], recommendation: &quot;Silent migration — no logout required for existing sessions&quot; },
    devil:     { verdict: &quot;warn&quot;,    reason: &quot;What if the refresh token store goes down at 2AM?&quot;, concerns: [&quot;Redis outage = all users logged out&quot;], recommendation: &quot;Fallback to session auth if Redis is down; use short rotation window&quot; },
    legal:     { verdict: &quot;approve&quot;, reason: &quot;JWTs are industry standard, no new compliance risk&quot;, concerns: [], recommendation: &quot;Document token storage in privacy policy&quot; },
    security:  { verdict: &quot;warn&quot;,    reason: &quot;Refresh token rotation must be atomic — TOCTOU risk&quot;, concerns: [&quot;localStorage storage of access token is XSS-vulnerable&quot;], recommendation: &quot;Store access token in memory only; refresh token in httpOnly Secure SameSite=Strict cookie&quot; }
  }
}
→ {
    llm_backed: true,
    final_verdict: &quot;YELLOW&quot;,
    warnings: [&quot;Refresh token rotation must be atomic...&quot;, &quot;What if the refresh token store goes down...&quot;],
    recommended: &quot;Proceed with JWT. Use httpOnly cookies for refresh tokens, memory-only for access tokens...&quot;
  }

Council `strictness````

veto_council_debate { task: "...", strictness: "fast" } # 3 agents, instant
veto_council_debate { task: "...", strictness: "standard" } # 7 agents, default
veto_council_debate { task: "...", strictness: "strict" } # 7 + devil rebuttal


---

## Session Tagging + Search```
veto_session_save {
  auto_summarize: true,
  tags: [&quot;auth&quot;, &quot;jwt&quot;, &quot;middleware&quot;]
}

veto_sessions_list { query: &quot;auth&quot; }
→ sessions matching &quot;auth&quot; in summary, context, tags, or project_dir

Token usage is manually reported — pass token_count to veto_status or veto_session_save and Veto stores it per platform per day. veto_rate_status shows what you've reported; nothing is counted automatically.


Workspace Discovery```

veto_discover { "project_dir": "/your/project" }
→ {
git: { branch: "main", commit: "a3f2b1", dirty_files: [], recent_commits: [...] },
ecosystems: { node: "my-app v2.1.0" },
tech_stack: ["TypeScript", "React", "Prisma"],
key_files: ["tsconfig.json", "prisma/schema.prisma", ".env.example"],
total_files: 142
}


---

## Diff Review```
veto_diff_review { project_dir: &quot;/your/project&quot; }
→ {
    verdict: &quot;warn&quot;,
    files_changed: 4,
    code_review: { score: 78, critical: 0, high: 2, findings: [...] },
    security:    { score: 91, critical: 0, high: 0, findings: [...] },
    secrets:     { findings: [] },
    summary: &quot;⚠️  WARN — 4 file(s) changed...&quot;
  }

Sequential Pipelines```

veto_workflow {
steps: [
{ id: "code", agent: "coder", task: "implement auth middleware", gate: 70 },
{ id: "review", agent: "reviewer", task: "review the implementation", gate: 75 },
{ id: "security", agent: "security-scanner", task: "scan for vulnerabilities", gate: 80 },
{ id: "test", agent: "tester", task: "write test cases" }
],
project_dir: "/your/project"
}
→ { verdict: "passed", steps_passed: 4, steps_failed: 0, results: [...] }


---

## Self-Learning Router

Every agent tool auto-records a quality signal when it completes. After any working session, `veto_learning_stats` shows live data and `veto_learning_apply` adjusts tier thresholds automatically after ~20 calls.

The loop also feeds itself **implicitly**: `veto_learning_stats` mines the tool-call trace for signals nobody recorded manually — an agent-backed tool that returned an error, or the same analysis tool re-run within minutes in one session (which usually means the first answer didn&#x27;t satisfy) — and records them as low-quality outcomes automatically.```bash
veto_route_task { task: &quot;debug auth issue&quot;, file_ext: &quot;.ts&quot; }
→ { ..., recommended_agent: &quot;debugger&quot; }   # ← predicted from history

Plugin System```js

// ~/.veto/agents/my-agent.js
export function plan(task, context) {
return {
agent: 'my-agent', task, tier: 2,
approach: 'Your custom approach...',
steps: ['Step 1', 'Step 2'],
checklist: ['[ ] Check 1'],
pitfalls: ['Pitfall 1'],
patterns: ['Pattern 1'],
duration_estimate: '1-2 hours',
};
}


---

## Cross-Platform Handoff```
Claude at 90%  →  veto_handoff { summary, context }
Open Gemini    →  veto_continue { resuming_as: &quot;gemini&quot; }
Full context restored. Continue exactly where you stopped.

Platform switching is manual — Veto surfaces which platform has budget remaining via veto_rate_status, you decide when to switch.

Platform Support
Claude Code ✅ Native MCP
Gemini CLI ✅ MCP support
Antigravity CLI ✅ MCP support
Codex CLI ✅ MCP support
Cursor ✅ MCP support
Windsurf ✅ MCP support
Zed ✅ MCP support (context_servers)

Session Transcript Capture (opt-in)

veto_session_save writes a ~1k-token summary. That is enough to resume, but not enough to answer "three weeks ago, what exactly did we conclude, and when?" Transcript capture keeps the detail a summary throws away and makes it searchable — with no API keys, no per-query cost, and nothing leaving your machine. It is a metadata table-of-contents plus a portable BM25 index built on core SQLite only — no FTS5, so it works on every supported Node — fused with local semantic search, and your AI as the reranker.

> ### ⚠️ Read this before you enable it
>
> Veto copies your AI client's own conversation memory. On save, Veto archives a byte-for-byte copy of the host CLI's transcript file — every message you sent, every reply, and all tool activity — into its own local store.
>

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Veto 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Veto 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Veto 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Veto 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Veto 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Windsurf、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Veto 能提供哪些能力?

资料显示能力标签包括 mcp、mcp server、ai agents、code review、security、memory。具体工具清单以官方文档为准。

Veto 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。