@jigyasudham/veto 2.7.2 → 2.7.3

package/LAUNCH-KIT.md

@@ -1,226 +0,0 @@
-# Veto Launch Kit
-
-Ready-to-paste copy for distribution. Facts current as of v2.5.0 (npm latest + official MCP Registry).
-Core hook: **93 agentic tools + a 49-specialist agent council for every major AI CLI, at zero extra
-token cost on subscription plans.**
-
-> **New in v2.2–2.5 (lead with these — they're the cleanest expression of the "Veto" name):**
-> a guardrail layer that catches AI mistakes before they ship —
-> `veto_dep_verify` (dependency-hallucination guard: flags packages the AI invented),
-> `veto_decisions` (decision-drift enforcement: stops the AI quietly reversing an agreed choice), and
-> `veto_drift_check` (compounding-error circuit breaker). This is the launch's strongest story.
-
-Canonical links:
-- npm: https://www.npmjs.com/package/@jigyasudham/veto
-- GitHub: https://github.com/jigyasudham/veto
-- MCP Registry: `io.github.jigyasudham/veto`
-- Quickstart: `npx @jigyasudham/veto@latest init`  (avoid `npm i -g` — a global install shadows npx and pins you to an old version)
-
-> Honesty guardrail used throughout: "zero cost" = subscription plans (Claude Max, Gemini Advanced…).
-> On API/pay-per-token billing, MCP Sampling calls count toward usage. Keep that caveat in every post.
-
----
-
-## 1. awesome-mcp-servers PR
-
-**Repo:** https://github.com/punkpeye/awesome-mcp-servers
-**Section:** `## 🤖 Coding Agents` (alt: `## 🛠️ Developer Tools`)
-**Legend used:** 📇 TypeScript · 🏠 local service · 🍎 macOS · 🪟 Windows · 🐧 Linux
-
-**Entry line (alphabetical by `owner/name` within the section):**
-
-```
-- [jigyasudham/veto](https://github.com/jigyasudham/veto) 📇 🏠 🍎 🪟 🐧 - 93 agentic tools and a 49-specialist agent council (Lead Dev, Architect, Security…) for every major AI CLI — Claude Code, Codex, Gemini, Cursor, Windsurf. Self-learning router, cross-platform memory, dependency-hallucination + decision-drift guards, deterministic agents that optionally upgrade to LLM. Zero extra token cost on subscriptions.
-```
-
-**Submit steps:**
-```bash
-gh repo fork punkpeye/awesome-mcp-servers --clone
-# add the line under the Coding Agents section, keeping alphabetical order
-git checkout -b add-veto
-git commit -am "Add Veto — 93 MCP tools + 49-agent council for every AI CLI"
-git push -u origin add-veto
-gh pr create --repo punkpeye/awesome-mcp-servers --title "Add Veto" --body "Adds Veto: an MCP server giving every major AI CLI a 49-specialist agent council + 93 tools, using existing subscriptions (no API keys). MIT, on the official MCP registry as io.github.jigyasudham/veto."
-```
-
----
-
-## 2. Show HN
-
-**Title (submit the GitHub URL as the link):**
-```
-Show HN: Veto – 93 MCP tools and a 49-agent council for every AI CLI
-```
-
-**First comment (post immediately after submitting):**
-```
-Hi HN — I built Veto, a single MCP server that plugs into whatever AI CLI you already
-use (Claude Code, Codex, Gemini, Cursor, Windsurf, Zed, JetBrains) and gives it 93 tools
-and a council of 49 specialist agents — code review, security/secrets scanning, a 7-agent
-"should we build this" debate, CI gates, SDD agents, guards that catch dependency
-hallucinations and decision drift, and persistent memory that follows you across CLIs.
-
-The design decision I'd most like feedback on: the 42 worker agents are *deterministic
-expert modules by default* (regex/AST secret detection, OWASP/CWE rules, complexity metrics)
-— they run offline and cost zero tokens. When your client supports MCP Sampling they
-optionally upgrade to real LLM reasoning on your existing subscription. So "49 agents" isn't
-49 LLM calls; it's mostly real code with an LLM layer you opt into. The 7-agent Council is
-the LLM-first part (it debates trade-offs before you build) and falls back to a deterministic
-verdict when Sampling isn't available.
-
-Cost: on a subscription (Claude Max, Gemini Advanced) the LLM calls ride your existing plan,
-so there's no extra bill. On API/pay-per-token billing those Sampling calls do count — `veto
-init` detects API keys and warns you.
-
-It's MIT, on npm and the official MCP registry. Try it: `npx @jigyasudham/veto init`
-
-Repo: https://github.com/jigyasudham/veto
-
-Happy to go deep on the router (it re-tunes its tier thresholds every 20 recorded outcomes)
-or the cross-CLI memory/handoff. What would you want a tool like this to NOT do?
-```
-
-> HN tips: post Tue–Thu ~8–10am ET. Don't ask for upvotes. Reply fast and non-defensively;
-> the skeptical "isn't 93 tools bloat?" question is your best moment — answer it with the
-> deterministic-vs-LLM architecture above.
-
----
-
-## 3. Reddit posts (tailored — do NOT cross-post identical text)
-
-### r/ClaudeAI  (and r/ClaudeCode)
-**Title:** I gave Claude Code a 49-agent council + persistent memory across CLIs — open source, no API keys
-**Body:**
-```
-Veto is an MCP server I've been building that adds 93 tools + 49 specialist agents to Claude
-Code using your existing Claude subscription (no separate API key, no extra token bill on
-Max/Pro).
-
-What it actually does day to day:
-- /code-review and security/secrets scans as MCP tools
-- a 7-agent Council (Lead Dev, Architect, Security, Devil's Advocate, Legal, PM, UX) that
-  debates a plan before you build it
-- memory that saves your session and restores it in Gemini CLI or Codex if you switch — the
-  handoff carries full context
-- guards that catch the AI's own mistakes: dependency-hallucination detection (flags packages
-  it invented), decision-drift enforcement (stops it reversing a choice you already made), and a
-  compounding-error circuit breaker
-- a self-learning router that re-tunes which model tier handles which task
-
-Most worker agents are deterministic (real OWASP/CWE/secret-detection code), and upgrade to
-LLM reasoning via MCP Sampling only when you ask — so it works offline and costs nothing extra
-on a subscription. (API billing: Sampling calls do count; it warns you.)
-
-MIT, on npm + the official MCP registry. `npx @jigyasudham/veto init` sets it up for every CLI
-it detects. Repo + GIF: https://github.com/jigyasudham/veto
-
-Would love feedback on what's missing.
-```
-
-### r/LocalLLaMA
-**Title:** MCP server with 49 agents that run deterministically offline + optional local LLM — MIT
-**Body:**
-```
-Sharing Veto in case it's useful here: it's an MCP server whose 42 worker agents are
-hand-written deterministic modules (AST/regex secret detection, OWASP/CWE rules, complexity
-metrics) — they run offline at zero token cost. There's a local-LLM tool and MCP Sampling
-support, so you can route the reasoning layer to a local model instead of a hosted one.
-
-It also does cross-CLI session memory, a multi-agent council debate, CI gates, and secrets
-scanning, and works with Claude Code / Codex / Gemini / Cursor / Windsurf / Zed / JetBrains.
-
-MIT, npm + official MCP registry. `npx @jigyasudham/veto init`.
-Repo: https://github.com/jigyasudham/veto — keen on feedback re: wiring it to local backends.
-```
-
-### r/ChatGPTCoding
-**Title:** Open-source MCP server: 93 tools + 49-agent council that works across Codex, Claude, Gemini & Cursor
-**Body:**
-```
-Veto is an MCP server that gives whatever AI coding CLI you use (Codex, Claude Code, Gemini,
-Cursor, Windsurf) a shared layer: 93 tools, a 49-specialist agent council, code review +
-security scanning, CI gates, and memory that follows you when you switch tools.
-
-The agents are deterministic by default and upgrade to LLM reasoning only when your client
-supports it — so on a subscription there's no extra token cost (API billing does count; it
-warns you). MIT, on npm + the official MCP registry.
-
-Setup is one command: `npx @jigyasudham/veto init`
-https://github.com/jigyasudham/veto
-```
-
-> Reddit tips: post the GIF natively if the sub allows it (huge engagement boost). Lead with
-> utility, not metrics. Reply to every comment in the first 2 hours. Read each sub's
-> self-promo rules first — some require a flair or a ratio of non-promo participation.
-
----
-
-## 4. X/Twitter thread
-
-```
-1/ I shipped Veto — one MCP server that gives every major AI CLI a council of 49 specialist
-agents + 93 tools, using your existing subscription. No API keys. No extra token bill.
-
-Claude Code, Codex, Gemini, Cursor, Windsurf, Zed, JetBrains — same superpowers everywhere.
-[attach veto.gif]
-
-2/ The trick: the 42 worker agents are deterministic expert modules by default — real
-OWASP/CWE rules, AST secret detection, complexity metrics. They run offline at zero cost,
-and *optionally* upgrade to LLM reasoning via MCP Sampling on your existing plan.
-
-3/ The other 7 are a Council — Lead Dev, Architect, Security, Devil's Advocate, PM, UX, Legal
-— that debates a plan before you build it and hands you a GREEN/YELLOW/RED verdict with the
-actual trade-offs. It's saved me from a few bad calls already.
-
-4/ And it remembers. Save a session in Claude Code, restore it in Gemini CLI mid-task — the
-handoff carries full context. Plus a router that re-tunes itself every 20 outcomes.
-
-5/ The newest part lives up to the name: a guardrail layer that vetoes the AI's own mistakes —
-catches packages it hallucinated, blocks it from quietly reversing a decision you already made,
-and trips a circuit breaker on compounding errors.
-
-6/ MIT. On npm and the official MCP registry.
-
-One command: npx @jigyasudham/veto init
-
-⭐ https://github.com/jigyasudham/veto
-```
-
-> Tag the GIF on tweet 1 (video/gif tweets get far more reach). Quote-tweet it when you hit
-> milestones. Reply to "best MCP servers" threads with tweet 1.
-
----
-
-## 5. Directory submission kit (paste into glama.ai / smithery.ai / mcp.so / pulsemcp / mcpservers.org)
-
-**Name:** Veto
-**Package:** `@jigyasudham/veto`  ·  **Registry name:** `io.github.jigyasudham/veto`
-**Repo:** https://github.com/jigyasudham/veto  ·  **License:** MIT  ·  **Transport:** stdio
-**Install:** `npx @jigyasudham/veto init`
-**Categories/tags:** mcp, agents, code-review, security, memory, council, router, ci-cd,
-self-learning, multi-agent, developer-tools
-
-**Short description (<=100 chars — matches server.json):**
-```
-93 agentic MCP tools + 49 specialist agents for every major AI CLI. Self-learning, no API keys.
-```
-
-**One-liner:**
-```
-A council of 49 specialist agents + 93 tools for every AI CLI, using your existing subscription.
-```
-
-**Long description:**
-```
-Veto is a local MCP server that gives every major AI CLI — Claude Code, Codex, Gemini,
-Antigravity, Cursor, Windsurf, Zed, JetBrains — a shared layer of 93 agentic tools and 49
-specialist agents. 42 worker agents (across dev, security, memory, research, quality, and
-workflow domains) run as deterministic expert modules by default and optionally upgrade to LLM
-reasoning via MCP Sampling; a 7-agent Council debates trade-offs before you build. It adds code
-review, security and secrets scanning, CI gates, SDD agents, Playwright automation, a guardrail
-layer that catches the AI's own mistakes (dependency-hallucination detection, decision-drift
-enforcement, and a compounding-error circuit breaker), a self-learning router that re-tunes its
-thresholds every 20 outcomes, and persistent memory that hands off your session across CLIs. On
-a subscription it costs nothing extra; on API billing, Sampling calls count and it warns you.
-MIT licensed.
-```

package/MCP-REGISTRY.md

@@ -1,94 +0,0 @@
-# Publishing Veto to the official MCP Registry
-
-This document is the runbook for listing Veto on the [official Model Context
-Protocol registry](https://registry.modelcontextprotocol.io) so it appears on
-official sources and in registry-backed directories. The registry entry is
-defined by [`server.json`](../server.json) at the repo root.
-
-## How the registry verifies ownership
-
-The registry does **not** host the package — it points at the npm package
-`@jigyasudham/veto`. To prove we own that package, the registry fetches
-`https://registry.npmjs.org/@jigyasudham/veto/<version>` and reads the
-top-level **`mcpName`** field from the published `package.json`. It must equal
-the `name` in `server.json`:
-
-```
-io.github.jigyasudham/veto
-```
-
-The `io.github.jigyasudham/*` namespace is owned by proving control of the
-GitHub account `jigyasudham` (interactive OAuth at publish time).
-
-> **Critical ordering:** the npm version referenced in `server.json` must
-> already be published **with** the `mcpName` field. The previously published
-> `2.1.1` did **not** have `mcpName`, which is why this listing ships as
-> `2.1.2` — the first npm release that carries it. Always `npm publish` first,
-> then `mcp-publisher publish`.
-
-## Files involved
-
-| File | Role |
-|---|---|
-| `server.json` | The registry entry (schema `2025-12-11`). Name, description (≤100 chars), repository, and the npm package + stdio transport. |
-| `package.json` | Carries `"mcpName": "io.github.jigyasudham/veto"` — the ownership proof read off npm. Keep its `version` equal to `server.json` `version` and `packages[0].version`. |
-
-Keep all three version fields in lockstep on every release:
-`package.json.version` == `server.json.version` == `server.json.packages[0].version`.
-
-## Publish steps
-
-Run from the repo root, on a clean `main` at the tagged release commit.
-
-1. **Publish the npm release that carries `mcpName`** (the user does this — it
-   needs npm credentials):
-
-   ```bash
-   npm run build
-   npm publish --access public        # publishes @jigyasudham/veto@2.1.2
-   ```
-
-   Verify the field landed on npm:
-
-   ```bash
-   curl -s https://registry.npmjs.org/@jigyasudham/veto/2.1.2 | grep -o '"mcpName":"[^"]*"'
-   # -> "mcpName":"io.github.jigyasudham/veto"
-   ```
-
-2. **Install the registry publisher CLI** (`mcp-publisher`). Either download a
-   release binary from
-   [`modelcontextprotocol/registry`](https://github.com/modelcontextprotocol/registry/releases)
-   or build from source (`make publisher` -> `./bin/mcp-publisher`).
-
-3. **Authenticate the namespace** with the GitHub account `jigyasudham`
-   (interactive — opens a browser):
-
-   ```bash
-   mcp-publisher login github
-   ```
-
-4. **Validate and publish** the entry (reads `server.json` from the cwd):
-
-   ```bash
-   mcp-publisher publish
-   ```
-
-   The registry re-runs npm ownership validation server-side; if step 1 was
-   skipped it fails with *"NPM package is missing required 'mcpName' field"*.
-
-5. **Confirm the listing:**
-
-   ```bash
-   curl -s "https://registry.modelcontextprotocol.io/v0/servers?search=veto" | grep -o '"name":"io.github.jigyasudham/veto"'
-   ```
-
-## Updating the listing on future releases
-
-For each new release: bump `version` in `package.json` **and** both version
-fields in `server.json`, `npm publish`, then re-run `mcp-publisher publish`.
-The `mcpName` field never changes.
-
-## Lifecycle
-
-Use `mcp-publisher status` to move the server between `active`, `deprecated`,
-and `deleted` states if needed.

package/VETO-MCP-DIAGNOSTIC.md

@@ -1,73 +0,0 @@
-# Veto MCP — connection failure diagnostic
-
-Run these in the **failing VS Code window's project terminal** (the project where the
-`veto_*` tools won't load). Paste all output back.
-
-Context: Veto's server imports `node:sqlite` at startup, which needs **Node >= 22.5.0**.
-If that window resolves an older Node, the server throws and exits immediately — the exact
-"launches but never runs the stdio loop" symptom. These four checks pin down the cause.
-
----
-
-## Run this block (PowerShell)
-
-```powershell
-# 1. What command is this project actually configured to launch for veto?
-claude mcp get veto
-
-# (fallback if the above errors)
-claude mcp list
-
-# 2. Node version this window resolves — MUST be >= 22.5.0
-node --version
-
-# 3. Can a bare `veto-server` even resolve, and is it installed globally?
-where.exe veto-server
-npm ls -g @jigyasudham/veto
-
-# 4. Decisive test — launch the server directly and watch what it prints:
-npx -y --package @jigyasudham/veto veto-server
-```
-
-For step 4:
-- **GOOD** -> prints `Veto MCP server v2.1.2 running (stdio)` then hangs. Press **Ctrl+C** to exit.
-- **BAD**  -> an error/stack trace (copy the whole thing) OR it returns to the prompt instantly.
-
----
-
-## What each result means
-
-| Check | If this is the problem | Fix |
-|---|---|---|
-| **#2 Node < 22.5.0** | `node:sqlite` import throws -> server exits immediately | Point the MCP command at a Node >= 22.5.0, or use the `npx` form below (it inherits PATH — make sure that PATH's Node is >= 22.5.0). |
-| **#3 `veto-server` not found** | config launches a bare `veto-server` that isn't on PATH | Use the `npx` command form below instead of a bare binary. |
-| **#1 config points at `dist/server.js` of a different/uninstalled path** | wrong launcher | Repoint to the `npx` form below. |
-| **#4 prints a stack trace** | the package itself errors in this environment | Copy the trace — that's the real bug; bring it back here. |
-| **#4 GOOD but tools still fail in-CLI** | config command != the working `npx` one | Repoint config to the `npx` form, then fully restart the CLI. |
-
----
-
-## The likely fix (repoint the config to the known-good launcher)
-
-Update that project's veto MCP server entry to:
-
-```json
-{
-  "command": "npx",
-  "args": ["-y", "--package", "@jigyasudham/veto", "veto-server"]
-}
-```
-
-Or via CLI from that project dir:
-
-```powershell
-claude mcp remove veto
-claude mcp add veto -- npx -y --package @jigyasudham/veto veto-server
-```
-
-Then **fully restart Claude Code** — MCP config is read only at startup, so the current
-in-memory session won't recover; the next launch will.
-
-Note: `npx -y` now pulls **2.1.2** (latest), so a healthy run reports `v2.1.2`.
-Verify the resolved Node behind `npx` is >= 22.5.0 (`node --version`), or the npx form
-will fail the same way.