guardvibe 3.1.42 → 3.3.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to GuardVibe are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.0] - 2026-06-07
+
+### Added — diff-aware scanning: block what you just wrote, not the backlog (438 rules / 37 tools)
+- **`guardvibe diff [base]` is now diff-aware by default** — it reports only findings on lines the change actually **added**, instead of re-reporting pre-existing debt in every file you touched. This makes the gate actionable: it blocks the issues newly introduced vs the base, the ones an AI agent just wrote.
+- **Transparent, never silent:** the report states the mode and how many pre-existing findings on unchanged lines were hidden (`preExistingHidden` in JSON; a note in markdown). `--all-lines` restores the whole-changed-file view.
+- New module `src/tools/diff-aware.ts` — a pure, git-free unified-diff hunk parser (`addedLinesFromUnifiedDiff`) plus thin `git diff` wrappers (`getAddedLinesForDiff`, `getAddedLinesStaged`) and a `filterToAddedLines` helper. Unit-tested independent of git; works at any `--unified` context level; counts newly-added files as fully added; ignores deletions.
+- No rule or tool changes (438 / 37).
+
+Gate green (build / lint / test / self-audit PASS / A / 0).
+
+## [3.2.0] - 2026-06-07
+
+### Added — `secure_this`: close the loop from "warns" to "guarantees the fix landed" (438 rules / 37 tools)
+- **New tool `secure_this`** (MCP + CLI `guardvibe secure-this <file>`). It scans a file, applies only the auto-fixes that **verifiably land**, and re-verifies — converting GuardVibe from a tool that *reports* findings into one that *guarantees the fix landed*.
+- **Verify-and-rollback loop:** every candidate edit from `fix_code` is applied to a copy and re-scanned; the edit is kept only if it (1) strictly reduces the finding set and (2) introduces no new finding. Any edit that fails either check is rolled back. The loop repeats until no further verified fix is available.
+- **Definition-of-done gate:** the result carries `definitionOfDone.passed` — the agent must pass it before claiming a task complete. `status` is `clean` / `secured` / `partial` / `no_autofix`; `applied[]` lists verified fixes, `remaining[]` lists findings that need a manual fix (with guidance).
+- **Deterministic:** same code in → same code out (fixes applied in a fixed line/rule order; verified by the deterministic `analyzeFileSecurity`).
+- **CLI:** `secure-this <file>` is dry-run by default (shows what would land + remaining manual work); `--write` applies only the verified fixes to disk; `--format json` for agents. Exit code gates a pre-commit hook / CI step (1 while real findings remain).
+- Tool count 36 → 37. No rule changes (438).
+
+Gate green (build / lint / test / self-audit PASS / A / 0).
+
 ## [3.1.42] - 2026-06-07
 
 ### Fixed — MCP registry description length (no rule-count change, 438 / 36)

package/README.md

@@ -14,7 +14,7 @@
 - **🗺️ Sees the whole repo.** Cross-file taint + auth-coverage across every route — catches the unprotected endpoint your agent's narrow context missed.
 - **🔍 An independent second pair of eyes.** The thing that wrote the code can't review itself. GuardVibe is the outside checker on AI-written code — in the loop *while* your AI codes (real-time edit hook), not after.
 
-**The security MCP built for vibe coding.** 438 security rules, 36 tools covering the entire AI-generated code journey — from first line to production deployment.
+**The security MCP built for vibe coding.** 438 security rules, 37 tools covering the entire AI-generated code journey — from first line to production deployment.
 
 Works with **Claude Code, Cursor, Gemini CLI, Codex, VS Code (Copilot), Windsurf**, and any MCP-compatible coding agent.
 
@@ -26,7 +26,7 @@ Works with **Claude Code, Cursor, Gemini CLI, Codex, VS Code (Copilot), Windsurf
 
 Most security tools are built for enterprise security teams. GuardVibe is built for **you** — the developer using AI to build and ship web apps fast.
 
-- **438 security rules, 36 tools** purpose-built for the stacks AI agents generate
+- **438 security rules, 37 tools** purpose-built for the stacks AI agents generate
 - **Zero setup friction** — `npx guardvibe` and you're scanning
 - **No account required** — runs 100% locally, no API keys, no cloud
 - **Understands your stack** — not generic SAST, but rules that know Next.js, Supabase, Stripe, Clerk, and the tools you actually use
@@ -211,7 +211,7 @@ Maps security findings to SOC2, PCI-DSS, HIPAA, GDPR, ISO27001, and EU AI Act (E
 ### Supply Chain
 Malicious postinstall scripts, unpinned GitHub Actions, CI `npm` provenance / `--ignore-scripts` hardening (VG1070), typosquat detection, `node-ipc` protestware versions (VG1069), Miasma `@redhat-cloud-services` namespace compromise IOC (VG1074, RHSB-2026-006), Session messenger exfil endpoint IOC (VG1075, `filev2.getsession.org`), `@tanstack/*` Mini Shai-Hulud mass-malware versions (May 2026), `@wdio/browserstack-service` command injection via git branch names (CVE-2026-25244), lockfile poisoning patterns
 
-## Tools (36 MCP tools)
+## Tools (37 MCP tools)
 
 | Tool | What it does |
 |------|-------------|
@@ -227,6 +227,7 @@ Malicious postinstall scripts, unpinned GitHub Actions, CI `npm` provenance / `-
 | `export_sarif` | SARIF v2.1.0 export for CI/CD integration |
 | `get_security_docs` | Security best practices and guides |
 | `fix_code` | **Auto-fix suggestions** with concrete patches for AI agents |
+| `secure_this` | **Close the loop** — scan, apply only the fixes that verifiably land (each re-scanned, rolled back on regression), return the verified code + a definition-of-done gate |
 | `audit_config` | Audit project configuration files for cross-file security misconfigurations |
 | `generate_policy` | Detect project stack and generate tailored security policies (CSP, CORS, RLS) |
 | `review_pr` | Review PR diff for security issues with severity gating |
@@ -291,7 +292,13 @@ All scanning tools support `format: "json"` for machine-readable output.
 npx guardvibe scan [path]            # Scan a directory for security issues
 npx guardvibe scan . --format json   # JSON output for automation
 npx guardvibe check <file>           # Scan a single file
-npx guardvibe diff [base]            # Scan only changed files since git ref
+npx guardvibe diff [base]            # Scan changed files — reports only newly-introduced issues
+npx guardvibe diff [base] --all-lines # Include pre-existing findings in changed files too
+
+# Close the loop — scan, apply verified fixes, re-verify
+npx guardvibe secure-this <file>          # Dry run: show the fixes that would land + remaining manual work
+npx guardvibe secure-this <file> --write  # Apply only the fixes that re-verify clean (rolled back on regression)
+npx guardvibe secure-this <file> --format json
 
 # Full security audit
 npx guardvibe audit [path]           # Full audit with PASS/FAIL verdict + hash

package/build/cli/scan.js

@@ -78,9 +78,13 @@ export async function runDiffScan(base, flags) {
     const { execFileSync } = await import("child_process");
     const { analyzeFileSecurity } = await import("../tools/file-security.js");
     const { EXTENSION_MAP, CONFIG_FILE_MAP } = await import("../utils/constants.js");
+    const { getAddedLinesForDiff, filterToAddedLines } = await import("../tools/diff-aware.js");
     const format = validateFormat(flags);
     const outputFile = getOutputPath(flags);
     const root = resolve(".");
+    // Diff-aware by default: report only issues on newly-added lines. --all-lines
+    // restores the old whole-changed-file behavior (surfaces pre-existing debt too).
+    const allLines = flags["all-lines"] === true;
     let changedFiles;
     try {
         const output = execFileSync("git", ["diff", "--name-only", "--diff-filter=ACMR", base], { cwd: root, encoding: "utf-8" });
@@ -95,6 +99,7 @@ export async function runDiffScan(base, flags) {
         return;
     }
     const allFindings = [];
+    let preExistingHidden = 0;
     for (const relPath of changedFiles) {
         const fullPath = resolve(root, relPath);
         if (!existsSync(fullPath))
@@ -110,24 +115,34 @@ export async function runDiffScan(base, flags) {
         try {
             const content = readFileSync(fullPath, "utf-8");
             const findings = analyzeFileSecurity(content, language, undefined, fullPath, root);
-            for (const f of findings) {
+            let kept = findings;
+            if (!allLines) {
+                const added = getAddedLinesForDiff(base, relPath, root);
+                kept = filterToAddedLines(findings, added);
+                preExistingHidden += findings.length - kept.length;
+            }
+            for (const f of kept) {
                 allFindings.push({ file: relPath, severity: f.rule.severity, name: f.rule.name, id: f.rule.id, line: f.line, fix: f.rule.fix });
             }
         }
         catch { /* skip */ }
     }
+    const mode = allLines ? "all changed lines" : "newly-introduced lines only";
     let result;
     if (format === "json") {
         const critical = allFindings.filter(f => f.severity === "critical").length;
         const high = allFindings.filter(f => f.severity === "high").length;
         const medium = allFindings.filter(f => f.severity === "medium").length;
         result = JSON.stringify({
-            summary: { total: allFindings.length, critical, high, medium, changedFiles: changedFiles.length, blocked: critical > 0 || high > 0 },
+            summary: { total: allFindings.length, critical, high, medium, changedFiles: changedFiles.length, blocked: critical > 0 || high > 0, diffAware: !allLines, preExistingHidden },
             findings: allFindings,
         });
     }
     else {
-        const lines = [`# GuardVibe Diff Report`, ``, `Base: ${base}`, `Changed files: ${changedFiles.length}`, `Issues: ${allFindings.length}`, ``];
+        const lines = [`# GuardVibe Diff Report`, ``, `Base: ${base}`, `Mode: ${mode}`, `Changed files: ${changedFiles.length}`, `Issues: ${allFindings.length}`, ``];
+        if (!allLines && preExistingHidden > 0) {
+            lines.push(`> ${preExistingHidden} pre-existing finding(s) on unchanged lines hidden — re-run with \`--all-lines\` to see them.`, ``);
+        }
         if (allFindings.length === 0) {
             lines.push(`All changed files passed security checks.`);
         }

package/build/cli/secure-this.d.ts

@@ -0,0 +1 @@
+export declare function runSecureThis(args: string[]): Promise<void>;

package/build/cli/secure-this.js

@@ -0,0 +1,96 @@
+/**
+ * CLI: guardvibe secure-this <file> [--write] [--format json]
+ *
+ * Closes the loop: scans the file, applies only the fixes that verifiably land
+ * (each re-scanned, rolled back on regression), and reports a definition-of-done
+ * gate. Dry-run by default; `--write` applies the verified fixes to disk.
+ *
+ * Exit code: 0 when the file is (or was made) clean; 1 while real findings remain
+ * — so it can gate a pre-commit hook or CI step.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve, extname, basename } from "path";
+import { parseArgs } from "./args.js";
+import { secureThis } from "../tools/secure-this.js";
+import { EXTENSION_MAP, CONFIG_FILE_MAP } from "../utils/constants.js";
+function detectLanguage(resolvedPath) {
+    const ext = extname(resolvedPath).toLowerCase();
+    let language = EXTENSION_MAP[ext];
+    if (!language && basename(resolvedPath).startsWith("Dockerfile"))
+        language = "dockerfile";
+    if (!language)
+        language = CONFIG_FILE_MAP[basename(resolvedPath)];
+    return language;
+}
+function renderMarkdown(r, file, wrote) {
+    const badge = {
+        clean: "CLEAN ✅", secured: "SECURED ✅", partial: "PARTIAL ⚠️", no_autofix: "NO AUTO-FIX ❌",
+    };
+    const lines = [
+        `# GuardVibe secure_this — ${file}`,
+        "",
+        `**Status:** ${badge[r.status] ?? r.status}`,
+        `**Findings:** ${r.initialFindings} → ${r.finalFindings}`,
+        "",
+    ];
+    if (r.applied.length) {
+        lines.push(`## Applied & verified (${r.applied.length})`, "");
+        for (const a of r.applied) {
+            lines.push(`- **${a.ruleId}** (${a.severity}) line ${a.line}: ${a.ruleName}`);
+        }
+        lines.push("");
+    }
+    if (r.remaining.length) {
+        lines.push(`## Remaining — manual fix required (${r.remaining.length})`, "");
+        for (const f of r.remaining) {
+            lines.push(`- **${f.ruleId}** (${f.severity}) line ${f.line}: ${f.name}`);
+            if (f.fix)
+                lines.push(`  - Fix: ${f.fix}`);
+        }
+        lines.push("");
+    }
+    if (r.changed && !wrote) {
+        lines.push("> Dry run — re-run with `--write` to apply the verified fixes above.", "");
+    }
+    else if (wrote && r.changed) {
+        lines.push(`> Wrote ${r.applied.length} verified fix(es) to ${file}.`, "");
+    }
+    lines.push(`**Definition of done:** ${r.definitionOfDone.passed ? "PASSED ✅" : "FAILED ❌"} — ${r.definitionOfDone.message}`);
+    return lines.join("\n");
+}
+export async function runSecureThis(args) {
+    const { flags, positional } = parseArgs(args);
+    const filePath = positional[0];
+    if (!filePath) {
+        console.error("  [ERR] Please specify a file: npx guardvibe secure-this src/app/api/route.ts [--write]");
+        process.exit(1);
+    }
+    const resolved = resolve(filePath);
+    if (!existsSync(resolved)) {
+        console.error(`  [ERR] File not found: ${resolved}`);
+        process.exit(1);
+    }
+    const language = detectLanguage(resolved);
+    if (!language) {
+        console.error(`  [ERR] Unsupported file type: ${extname(resolved) || basename(resolved)}`);
+        process.exit(1);
+    }
+    const content = readFileSync(resolved, "utf-8");
+    const result = secureThis(content, language, { filePath: resolved });
+    const write = flags.write === true || flags.apply === true;
+    if (write && result.changed) {
+        writeFileSync(resolved, result.fixedCode, "utf-8");
+    }
+    const format = flags.format === "json" ? "json" : "markdown";
+    if (format === "json") {
+        console.log(JSON.stringify({ ...result, file: resolved, wrote: write && result.changed }));
+    }
+    else {
+        console.log(renderMarkdown(result, resolved, write && result.changed));
+    }
+    // Exit code gates a pre-commit hook / CI step.
+    // --write: pass iff the file ended clean. Dry-run: pass only if nothing to fix.
+    const ok = write ? result.definitionOfDone.passed : result.status === "clean";
+    if (!ok)
+        process.exit(1);
+}

package/build/cli.js

@@ -23,12 +23,13 @@ function printUsage() {
 
   Commands:
     npx guardvibe scan [path]        Scan a directory for security issues
-    npx guardvibe diff [base]        Scan only changed files since a git ref
+    npx guardvibe diff [base]        Scan changed files; reports only newly-introduced issues (--all-lines for whole files)
     npx guardvibe check <file>       Scan a single file for security issues
     npx guardvibe doctor [path]      Run host security audit
     npx guardvibe audit [path]       Full security audit with PASS/FAIL verdict
     npx guardvibe explain <ruleId>   Get detailed remediation guidance for a rule
     npx guardvibe fix <file>         Get security fix suggestions for a file
+    npx guardvibe secure-this <file> Scan, apply verified fixes, re-verify (--write to apply)
     npx guardvibe check-cmd "<cmd>"  Check if a shell command is safe to execute
     npx guardvibe auth-coverage [path]  Auth coverage analysis (Next.js routes)
     npx guardvibe compliance [path]     Compliance report (--framework SOC2|GDPR|...)
@@ -49,6 +50,7 @@ function printUsage() {
                           critical (default) | high | medium | low | none
     --baseline <file>     Compare against a previous scan JSON for fix tracking
     --save-baseline       Save current scan as baseline (.guardvibe-baseline.json)
+    --all-lines           (diff) Report all findings in changed files, not just newly-added lines
     --version, -V         Print version and exit
     --help, -h            Show this help message
 
@@ -145,6 +147,10 @@ async function main() {
         const { runFix } = await import("./cli/fix.js");
         await runFix(subArgs);
     }
+    else if (command === "secure-this" || command === "secure_this") {
+        const { runSecureThis } = await import("./cli/secure-this.js");
+        await runSecureThis(subArgs);
+    }
     else if (command === "check-cmd") {
         const { runCheckCmd } = await import("./cli/check-cmd.js");
         await runCheckCmd(subArgs);

package/build/index.js

@@ -41,6 +41,7 @@ import { doctor } from "./tools/doctor.js";
 import { formatHostFindings, redactSecrets } from "./server/types.js";
 import { verifyFix } from "./tools/verify-fix.js";
 import { fixCode as fixCodeTool } from "./tools/fix-code.js";
+import { secureThis } from "./tools/secure-this.js";
 import { analyzeAuthCoverage, formatAuthCoverage } from "./tools/auth-coverage.js";
 import { buildDeepScanPrompt, parseDeepScanResult, formatDeepScanFindings, callLLM } from "./tools/deep-scan.js";
 import { runFullAudit, formatAuditResult } from "./tools/full-audit.js";
@@ -315,6 +316,25 @@ server.tool("fix_code", "Pass vulnerable code as a string and get fix suggestion
         content: [{ type: "text", text: results }],
     };
 });
+// Tool 37: secure_this — close the loop (scan → apply verified fix → re-verify)
+server.tool("secure_this", "Close the loop on vulnerabilities in code: scan, apply only the fixes that VERIFIABLY land (each candidate edit is re-scanned and rolled back if it fails to resolve the issue or introduces a new one), and return the verified code plus a definition-of-done gate. Prefer this over fix_code+verify_fix when you want a guarantee the fix landed — not just a suggestion. Returns { status: clean|secured|partial|no_autofix, fixedCode, applied[], remaining[], definitionOfDone:{passed,message} }. Write fixedCode to disk, then require definitionOfDone.passed before claiming the task complete; anything in remaining[] needs a manual fix. Example: secure_this({code: '...', language: 'typescript'})", {
+    code: z.string().describe("The code to scan and secure"),
+    language: z
+        .enum(["javascript", "typescript", "python", "go", "dockerfile", "html", "sql", "shell", "yaml", "terraform", "firestore"])
+        .describe("Programming language of the code"),
+    framework: z.string().optional().describe("Framework context (e.g. express, nextjs, react)"),
+    filePath: z.string().optional().describe("File path for context-aware analysis (the file is NOT written; apply fixedCode yourself)"),
+}, async ({ code, language, framework, filePath }) => {
+    const rules = getRules();
+    const result = secureThis(code, language, { framework, filePath, rules });
+    if (result.applied.length > 0) {
+        try {
+            recordFix(process.cwd(), result.applied.length);
+        }
+        catch { /* stats best-effort */ }
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+});
 // Tool 13: Cross-file configuration security audit
 server.tool("audit_config", "Audit application config files (next.config, middleware, .env, vercel.json) for cross-file security gaps: missing headers, unprotected routes, exposed secrets. NOT the same as guardvibe_doctor which checks AI host security (MCP configs, hooks). Example: audit_config({path: '.'})", {
     path: z.string().describe("Project root directory to audit"),

package/build/tools/diff-aware.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parse unified-diff text and return the set of 1-based line numbers that are
+ * ADDED in the new version of the file. Works at any `--unified` context level.
+ */
+export declare function addedLinesFromUnifiedDiff(diff: string): Set<number>;
+/** Keep only findings whose line number is in the added-line set. */
+export declare function filterToAddedLines<T extends {
+    line: number;
+}>(findings: T[], added: Set<number>): T[];
+/** Lines added in `relPath` relative to a git base ref (branch/commit/HEAD~N). */
+export declare function getAddedLinesForDiff(base: string, relPath: string, cwd: string): Set<number>;
+/** Lines added in `relPath` in the staged (index) changes — for pre-commit gating. */
+export declare function getAddedLinesStaged(relPath: string, cwd: string): Set<number>;

package/build/tools/diff-aware.js

@@ -0,0 +1,78 @@
+/**
+ * Diff-aware scanning — surface only the issues that were NEWLY introduced.
+ *
+ * Scanning a changed file whole re-reports pre-existing debt the author didn't
+ * touch, which trains agents (and people) to ignore the output. Diff-aware
+ * filtering keeps only findings that land on lines the current change actually
+ * ADDED, so the gate blocks what you just wrote — not the backlog.
+ *
+ * The hunk parser is pure and git-free (unit-tested); a thin wrapper shells out
+ * to `git diff` to obtain the unified diff for a file.
+ */
+import { execFileSync } from "child_process";
+/**
+ * Parse unified-diff text and return the set of 1-based line numbers that are
+ * ADDED in the new version of the file. Works at any `--unified` context level.
+ */
+export function addedLinesFromUnifiedDiff(diff) {
+    const added = new Set();
+    let newLine = 0;
+    let inHunk = false;
+    for (const raw of diff.split("\n")) {
+        if (raw.startsWith("@@")) {
+            // @@ -oldStart,oldCount +newStart,newCount @@
+            const m = raw.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+            if (m) {
+                newLine = parseInt(m[1], 10);
+                inHunk = true;
+            }
+            continue;
+        }
+        if (!inHunk || raw === "")
+            continue;
+        if (raw.startsWith("+++") || raw.startsWith("---"))
+            continue;
+        const c = raw[0];
+        if (c === "+") {
+            added.add(newLine);
+            newLine++;
+        }
+        else if (c === "-") {
+            // deletion — present only in the old file, does not advance the new line
+        }
+        else if (c === "\\") {
+            // "" — metadata, ignore
+        }
+        else {
+            // context line (leading space) — advances the new-file line counter
+            newLine++;
+        }
+    }
+    return added;
+}
+/** Keep only findings whose line number is in the added-line set. */
+export function filterToAddedLines(findings, added) {
+    return findings.filter(f => added.has(f.line));
+}
+function gitDiffAddedLines(args, relPath, cwd) {
+    try {
+        const out = execFileSync("git", ["diff", "--no-color", "--unified=0", ...args, "--", relPath], {
+            cwd,
+            encoding: "utf-8",
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        return addedLinesFromUnifiedDiff(out);
+    }
+    catch {
+        // Not a git repo, untracked path, or git unavailable — caller decides fallback.
+        return new Set();
+    }
+}
+/** Lines added in `relPath` relative to a git base ref (branch/commit/HEAD~N). */
+export function getAddedLinesForDiff(base, relPath, cwd) {
+    return gitDiffAddedLines([base], relPath, cwd);
+}
+/** Lines added in `relPath` in the staged (index) changes — for pre-commit gating. */
+export function getAddedLinesStaged(relPath, cwd) {
+    return gitDiffAddedLines(["--cached"], relPath, cwd);
+}

package/build/tools/secure-this.d.ts

@@ -0,0 +1,47 @@
+import type { SecurityRule } from "../data/rules/types.js";
+export interface AppliedFix {
+    ruleId: string;
+    ruleName: string;
+    severity: string;
+    line: number;
+    before: string;
+    after: string;
+}
+export interface RemainingFinding {
+    ruleId: string;
+    name: string;
+    severity: string;
+    line: number;
+    reason: "no_autofix" | "fix_rejected";
+    fix: string;
+    fixCode?: string;
+}
+export type SecureThisStatus = "clean" | "secured" | "partial" | "no_autofix";
+export interface SecureThisResult {
+    status: SecureThisStatus;
+    changed: boolean;
+    initialFindings: number;
+    finalFindings: number;
+    resolved: string[];
+    applied: AppliedFix[];
+    remaining: RemainingFinding[];
+    passes: number;
+    fixedCode: string;
+    definitionOfDone: {
+        passed: boolean;
+        message: string;
+    };
+}
+export interface SecureThisOptions {
+    framework?: string;
+    filePath?: string;
+    configDir?: string;
+    rules?: SecurityRule[];
+    /** Hard backstop on apply passes (each accepted edit removes >=1 finding). */
+    maxPasses?: number;
+}
+/**
+ * Scan a file, apply only the fixes that verifiably land, and report a
+ * definition-of-done gate.
+ */
+export declare function secureThis(code: string, language: string, opts?: SecureThisOptions): SecureThisResult;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "guardvibe",
-  "version": "3.1.42",
+  "version": "3.3.0",
   "mcpName": "io.github.goklab/guardvibe",
-  "description": "Security infrastructure your AI can't be — deterministic, current past your model's training cutoff, whole-repo-aware, author-independent. Security MCP for vibe coding. 438 rules, 36 tools, CLI + doctor. Host security, auth coverage mapping, LLM-powered deep scan (IDOR/business logic), taint analysis. 67 CVE rules refreshed daily from GHSA/OSV/CISA KEV — Miasma @redhat-cloud-services compromise, Next.js May 2026 13-advisory cluster, Drizzle/MikroORM/Kysely SQL injection, Axios proxy-auth redirect leak, Hono setCookie attribute injection, Clerk SSRF, tRPC prototype pollution, @tanstack supply-chain, node-ipc protestware, OpenClaude sandbox bypass, plus the full AI-generated stack (Supabase, Stripe, Prisma, Hono, GraphQL, Convex, Turso, Uploadthing, AI SDK). 68 AI-native rules including OWASP MCP Top 10 tool-description prompt injection (VG1068), model-controlled sandbox-disable flag detection (VG1063), Session messenger exfil endpoint IOC (VG1075), and CI/CD supply-chain hardening (VG1070 npm --expect-provenance / --ignore-scripts enforcement).",
+  "description": "Security infrastructure your AI can't be — deterministic, current past your model's training cutoff, whole-repo-aware, author-independent. Security MCP for vibe coding. 438 rules, 37 tools, CLI + doctor. Host security, auth coverage mapping, LLM-powered deep scan (IDOR/business logic), taint analysis. 67 CVE rules refreshed daily from GHSA/OSV/CISA KEV — Miasma @redhat-cloud-services compromise, Next.js May 2026 13-advisory cluster, Drizzle/MikroORM/Kysely SQL injection, Axios proxy-auth redirect leak, Hono setCookie attribute injection, Clerk SSRF, tRPC prototype pollution, @tanstack supply-chain, node-ipc protestware, OpenClaude sandbox bypass, plus the full AI-generated stack (Supabase, Stripe, Prisma, Hono, GraphQL, Convex, Turso, Uploadthing, AI SDK). 68 AI-native rules including OWASP MCP Top 10 tool-description prompt injection (VG1068), model-controlled sandbox-disable flag detection (VG1063), Session messenger exfil endpoint IOC (VG1075), and CI/CD supply-chain hardening (VG1070 npm --expect-provenance / --ignore-scripts enforcement).",
   "type": "module",
   "bin": {
     "guardvibe": "build/cli.js",