cue-ai 0.3.0

package/resources/skills/scripts/sync-claude-desktop-mcps.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# One-way sync: ~/.claude.json `mcpServers` → ~/.config/Claude/claude_desktop_config.json
+#
+# Why: `claude mcp add` writes to ~/.claude.json (Claude Code's canonical
+# config). Claude Desktop reads its own file and doesn't share state. This
+# script propagates new/removed/changed MCPs into Desktop's config so a
+# Desktop restart picks them up.
+#
+# Adapter rules (Claude Desktop's stdio schema is stricter than Claude Code's):
+#   - Drop entries with type="http" / "sse" / a `url` field — those are remote
+#     MCPs and Desktop expects them via the Connectors UI, not local config.
+#     Keeping them in mcpServers makes Desktop reject the WHOLE block.
+#   - Strip the `type` field from stdio entries — Desktop's strict schema
+#     rejects entries that have it.
+#   - Preserve Desktop's existing `preferences` block byte-for-byte.
+#
+# Sync direction is one-way (CLI → Desktop). If you add an MCP via Desktop's
+# "Edit Config" UI, the next sync run will overwrite it from ~/.claude.json.
+# Treat ~/.claude.json as the source of truth for both CLI and Desktop MCPs.
+#
+# Idempotent: only writes when the resulting file content actually differs.
+# Silent on no-op. Best-effort: never blocks the calling sync.
+# Kill switch: export CLAUDE_DESKTOP_MCP_SYNC_OFF=1.
+
+set -euo pipefail
+
+if [[ "${CLAUDE_DESKTOP_MCP_SYNC_OFF:-0}" == "1" ]]; then
+  exit 0
+fi
+
+src="${HOME}/.claude.json"
+dst="${HOME}/.config/Claude/claude_desktop_config.json"
+
+[[ -f "$src" ]] || exit 0
+[[ -f "$dst" ]] || exit 0
+command -v jq >/dev/null 2>&1 || exit 0
+
+# ── REVERSE merge: if Desktop has stdio MCPs not in ~/.claude.json (because
+# user added them via Desktop's "Edit Config" UI), pull them back so the next
+# forward-sync pass doesn't wipe them. Skips http/sse entries.
+orphans=$(jq -r --slurpfile cli "$src" '
+  ($cli[0].mcpServers // {}) as $known
+  | (.mcpServers // {}) | to_entries
+  | map(
+      select(($known[.key] // null) == null)
+      | select((.value.type // "stdio") == "stdio")
+      | select((.value.command // null) != null)
+    )
+  | .[].key
+' "$dst" 2>/dev/null || true)
+
+if [[ -n "$orphans" ]]; then
+  bak="${src}.soul-backup"
+  cp -f "$src" "$bak"
+  merged=$(jq -s '
+    .[0] as $cli
+    | (.[1].mcpServers // {}) as $desktop
+    | $cli * { mcpServers: (
+        ($cli.mcpServers // {}) + (
+          $desktop | with_entries(
+            select((.value.type // "stdio") == "stdio")
+            | select((.value.command // null) != null)
+          )
+        )
+      ) }
+  ' "$src" "$dst" 2>/dev/null) || merged=""
+  if [[ -n "$merged" ]] && echo "$merged" | jq empty 2>/dev/null; then
+    tmp=$(mktemp "${src}.XXXXXX")
+    echo "$merged" > "$tmp"
+    mv "$tmp" "$src"
+    echo "[claude-desktop sync] reverse-merged orphans → ~/.claude.json (backup: $bak):" >&2
+    while IFS= read -r k; do echo "  + $k" >&2; done <<< "$orphans"
+  else
+    echo "[claude-desktop sync] reverse-merge produced invalid JSON; skipped" >&2
+  fi
+fi
+
+new_content=$(jq -s '
+  .[0].mcpServers as $cli_mcps |
+  .[1] as $desktop |
+  ( ($cli_mcps // {}) | with_entries(
+      select(
+        (.value.type // "stdio") != "http"
+        and (.value.type // "stdio") != "sse"
+        and (.value.url // null) == null
+      )
+      | .value |= (del(.type) | del(.url))
+    )
+  ) as $stdio_only |
+  ($desktop // {}) | .mcpServers = $stdio_only
+' "$src" "$dst" 2>/dev/null) || exit 0
+
+[[ -z "$new_content" ]] && exit 0
+
+old_norm=$(jq -S '.' "$dst" 2>/dev/null || echo '{}')
+new_norm=$(echo "$new_content" | jq -S '.')
+
+if [[ "$old_norm" == "$new_norm" ]]; then
+  exit 0
+fi
+
+# Show what's changing — useful when this fires from the timer
+diff_summary=$(diff <(echo "$old_norm" | jq -r '.mcpServers // {} | keys[]' 2>/dev/null | sort) \
+                    <(echo "$new_norm" | jq -r '.mcpServers // {} | keys[]' 2>/dev/null | sort) \
+                | grep -E '^[<>]' || true)
+
+# Atomic write: temp file then rename. Avoids a half-written file if Desktop
+# is reading at the same instant (it never is in practice — only reads on boot).
+tmp=$(mktemp "${dst}.XXXXXX")
+echo "$new_content" > "$tmp"
+mv "$tmp" "$dst"
+
+echo "[claude-desktop sync] mcpServers updated:" >&2
+[[ -n "$diff_summary" ]] && echo "$diff_summary" >&2
+
+# Best-effort desktop notification — non-blocking, ignored if notify-send absent
+if command -v notify-send >/dev/null 2>&1; then
+  notify-send -u low \
+    "Claude Desktop MCPs synced" \
+    "Restart Claude Desktop to load the new MCPs." 2>/dev/null || true
+fi
+
+exit 0

package/resources/skills/skills/browser/playwright/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: playwright
+description: Use when verifying storefront or admin UI changes visually, when the user asks "does it work?" / "screenshot the page" / "show me the form" / "check the checkout flow", when reproducing UI bugs reported by a user, when testing Medusa shop dev servers running on localhost ports, or when exploring a third-party site to understand its DOM/behavior.
+---
+
+# Playwright MCP — driving a real browser
+
+## Core principle
+
+When code touches anything rendered (Medusa storefronts, admin dashboards, Coolify UI, third-party docs), running tests or reading source isn't enough — load the page in a real browser, see what users see. Playwright MCP exposes `navigate`, `screenshot`, `click`, `fill`, `evaluate`, `accessibility_snapshot`, `network_log`, and friends so Claude can drive Chromium, Firefox, or WebKit from inside a conversation.
+
+## When to use
+
+- "Does the storefront still build after my change?" → navigate to the local dev URL, screenshot above-the-fold, check console errors.
+- "I changed the checkout button text — confirm it shows up." → navigate, screenshot the cart, verify the text in the accessibility snapshot.
+- "Reproduce the 500 on /blog/some-post" → navigate, capture the network_log, surface the failing request.
+- "What does marvahome.com look like in mobile viewport?" → navigate with viewport override, screenshot.
+- "Inspect the DOM of the Stripe Checkout page after redirect" → drive through the checkout, evaluate JS to dump the DOM.
+
+## When NOT to use
+
+- Pure data / API checks → use `curl` via Bash. Playwright is overkill and slow for JSON endpoints.
+- Reading documentation pages → `WebFetch` is faster (no browser cold-start).
+- Anything that needs a logged-in real user session against production → use Chrome DevTools MCP attached to your own Chrome instead (Playwright is incognito-clean by design).
+
+## Tool surface (after MCP loads)
+
+After restart, tools appear as `mcp__playwright__*`. The most-used:
+
+| Tool | Use |
+|---|---|
+| `navigate` | go to a URL |
+| `screenshot` | PNG bytes of viewport, full page, or a specific element |
+| `accessibility_snapshot` | tree of all visible elements with roles + labels (lighter than DOM) |
+| `click`, `fill`, `select_option`, `press_key` | drive forms |
+| `wait_for` | wait for selector / URL / network-idle |
+| `evaluate` | run arbitrary JS in the page context |
+| `network_log` | capture all requests + responses since navigate |
+| `console_log` | capture console output |
+| `set_viewport` | resize (mobile / tablet / desktop) |
+| `tab_new`, `tab_select`, `tab_close` | manage tabs |
+
+## Quick reference
+
+```javascript
+// Verify the marva storefront homepage renders
+await playwright.navigate({ url: "http://localhost:3001" })
+await playwright.screenshot({ fullPage: false })
+await playwright.accessibility_snapshot()   // for assertions
+
+// Reproduce a checkout failure
+await playwright.navigate({ url: "http://localhost:3001/checkout" })
+await playwright.fill({ selector: "[name=email]", value: "test@example.com" })
+await playwright.click({ selector: "button[type=submit]" })
+await playwright.wait_for({ url_pattern: "**/payment" })
+await playwright.network_log()             // see what fired
+await playwright.console_log()             // see errors
+```
+
+## Shop-specific patterns
+
+### Verifying a Medusa storefront change locally
+
+```bash
+# In one terminal — backend on its assigned port (see medusa-local-dev skill)
+medusa-dev start marva back
+
+# In another — storefront
+medusa-dev start marva front
+```
+
+Then ask Claude to:
+> "Open http://localhost:3001 in Playwright, screenshot it, then click the first product card and screenshot the PDP."
+
+### Comparing admin design changes side-by-side
+
+```javascript
+// before
+await playwright.navigate({ url: "http://localhost:9001/app/booking" })
+await playwright.screenshot({ filename: "before.png" })
+
+// apply change, restart backend, then
+await playwright.navigate({ url: "http://localhost:9001/app/booking" })
+await playwright.screenshot({ filename: "after.png" })
+```
+
+### Capturing what an end user sees after Stripe checkout
+
+```javascript
+await playwright.navigate({ url: "http://localhost:3001/cart" })
+// ... drive to Stripe redirect, fill 4242 4242 4242 4242 ...
+await playwright.wait_for({ url_pattern: "**/order/confirmed" })
+await playwright.screenshot({ fullPage: true })
+await playwright.console_log()    // any client-side errors?
+```
+
+## MCP registration
+
+Already added to `~/.claude.json` (under `mcpServers.playwright`). The entry uses `npx -y @playwright/mcp@latest --headless` so the package auto-updates and runs in headless mode by default. Drop `--headless` if you want the browser window to appear (useful when *you* want to watch what's happening).
+
+To restart Claude Code so the new MCP tools load:
+```
+# Just exit and re-run `claude` — the MCP comes up automatically.
+```
+
+## Browser binaries
+
+Chromium is installed at first use (or pre-installed via `npx playwright install chromium`). Adding Firefox/WebKit:
+```bash
+npx playwright install firefox webkit
+```
+
+Browsers live under `~/.cache/ms-playwright/`.
+
+## Common mistakes
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| `Target page, context or browser has been closed` | session timed out between calls | `navigate` again — Playwright MCP creates a new context per task |
+| Screenshots are blank / white | page hasn't finished rendering | `wait_for({ load_state: "networkidle" })` first |
+| Selector matches nothing | shadow DOM or iframe | use `accessibility_snapshot` to find the right role/name; for iframes pass `frame: "name"` |
+| Slow first navigate | Chromium cold-start (~2s) | normal; subsequent calls reuse the browser |
+| Network log empty | `network_log` only captures since the last `navigate` | call after the page settles |
+
+## When to escalate to Chrome DevTools MCP
+
+If you need to interact with your *already-open*, *already-logged-in* Chrome session (e.g., the Coolify dashboard with your live token), Playwright won't help — it always starts a fresh incognito-style context. For that, install `@modelcontextprotocol/server-chrome-devtools`, launch Chrome with `--remote-debugging-port=9222`, and use that MCP. Both can coexist.
+
+## When to escalate to Computer Use
+
+If the task crosses applications (browser ↔ terminal ↔ Stripe Dashboard ↔ Coolify UI all in one go), Anthropic's Computer Use loop is a better fit. Slower per step, but no MCP boundary.

package/resources/skills/skills/caveman/caveman/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: caveman
+description: >-
+  Use when user says "caveman mode", "be brief", "less tokens", or "/caveman". Ultra-compressed replies (lite/full/ultra).
+---
+
+# Caveman
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
+| **full** | Drop articles, fragments OK, short synonyms. Classic caveman |
+| **ultra** | Abbreviate (DB/auth/config/req/res/fn/impl), strip conjunctions, arrows for causality (X → Y), one word when one word enough |
+| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
+| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
+
+Example — "Why React component re-render?"
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop → new ref → re-render. `useMemo`."
+- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
+- wenyan-full: "物出新參照，致重繪。useMemo .Wrap之。"
+- wenyan-ultra: "新參照→重繪。useMemo Wrap。"
+
+Example — "Explain database connection pooling."
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool = reuse DB conn. Skip handshake → fast under load."
+- wenyan-full: "池reuse open connection。不每req新開。skip handshake overhead。"
+- wenyan-ultra: "池reuse conn。skip handshake → fast。"
+
+## Auto-Clarity
+
+Drop caveman for: security warnings, irreversible action confirmations, multi-step sequences where fragment order risks misread, user asks to clarify or repeats question. Resume caveman after clear part done.
+
+Example — destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

package/resources/skills/skills/caveman/caveman-commit/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: caveman-commit
+description: >-
+  Use when user says "write a commit", "commit message", or "/commit". Conventional Commits, intent-first subject, body only when why is non-obvious.
+---
+
+# Caveman Commit
+
+Write commit messages terse and exact. Conventional Commits format. No fluff. Why over what.
+
+## Rules
+
+**Subject line:**
+- `<type>(<scope>): <imperative summary>` — `<scope>` optional
+- Types: `feat`, `fix`, `refactor`, `perf`, `docs`, `test`, `chore`, `build`, `ci`, `style`, `revert`
+- Imperative mood: "add", "fix", "remove" — not "added", "adds", "adding"
+- ≤50 chars when possible, hard cap 72
+- No trailing period
+- Match project convention for capitalization after the colon
+
+**Body (only if needed):**
+- Skip entirely when subject is self-explanatory
+- Add body only for: non-obvious *why*, breaking changes, migration notes, linked issues
+- Wrap at 72 chars
+- Bullets `-` not `*`
+- Reference issues/PRs at end: `Closes #42`, `Refs #17`
+
+**What NEVER goes in:**
+- "This commit does X", "I", "we", "now", "currently" — the diff says what
+- "As requested by..." — use Co-authored-by trailer
+- "Generated with Claude Code" or any AI attribution
+- Emoji (unless project convention requires)
+- Restating the file name when scope already says it
+
+## Examples
+
+Diff: new endpoint for user profile with body explaining the why
+- ❌ "feat: add a new endpoint to get user profile information from the database"
+- ✅
+  ```
+  feat(api): add GET /users/:id/profile
+
+  Mobile client needs profile data without the full user payload
+  to reduce LTE bandwidth on cold-launch screens.
+
+  Closes #128
+  ```
+
+Diff: breaking API change
+- ✅
+  ```
+  feat(api)!: rename /v1/orders to /v1/checkout
+
+  BREAKING CHANGE: clients on /v1/orders must migrate to /v1/checkout
+  before 2026-06-01. Old route returns 410 after that date.
+  ```
+
+## Auto-Clarity
+
+Always include body for: breaking changes, security fixes, data migrations, anything reverting a prior commit. Never compress these into subject-only — future debuggers need the context.
+
+## Boundaries
+
+Only generates the commit message. Does not run `git commit`, does not stage files, does not amend. Output the message as a code block ready to paste. "stop caveman-commit" or "normal mode": revert to verbose commit style.

package/resources/skills/skills/caveman/caveman-compress/README.md

@@ -0,0 +1,163 @@
+<p align="center">
+  <img src="https://em-content.zobj.net/source/apple/391/rock_1faa8.png" width="80" />
+</p>
+
+<h1 align="center">caveman-compress</h1>
+
+<p align="center">
+  <strong>shrink memory file. save token every session.</strong>
+</p>
+
+---
+
+A Claude Code skill that compresses your project memory files (`CLAUDE.md`, todos, preferences) into caveman format — so every session loads fewer tokens automatically.
+
+Claude read `CLAUDE.md` on every session start. If file big, cost big. Caveman make file small. Cost go down forever.
+
+## What It Do
+
+```
+/caveman:compress CLAUDE.md
+```
+
+```
+CLAUDE.md          ← compressed (Claude reads this — fewer tokens every session)
+CLAUDE.original.md ← human-readable backup (you edit this)
+```
+
+Original never lost. You can read and edit `.original.md`. Run skill again to re-compress after edits.
+
+## Benchmarks
+
+Real results on real project files:
+
+| File | Original | Compressed | Saved |
+|------|----------:|----------:|------:|
+| `claude-md-preferences.md` | 706 | 285 | **59.6%** |
+| `project-notes.md` | 1145 | 535 | **53.3%** |
+| `claude-md-project.md` | 1122 | 636 | **43.3%** |
+| `todo-list.md` | 627 | 388 | **38.1%** |
+| `mixed-with-code.md` | 888 | 560 | **36.9%** |
+| **Average** | **898** | **481** | **46%** |
+
+All validations passed ✅ — headings, code blocks, URLs, file paths preserved exactly.
+
+## Before / After
+
+<table>
+<tr>
+<td width="50%">
+
+### 📄 Original (706 tokens)
+
+> "I strongly prefer TypeScript with strict mode enabled for all new code. Please don't use `any` type unless there's genuinely no way around it, and if you do, leave a comment explaining the reasoning. I find that taking the time to properly type things catches a lot of bugs before they ever make it to runtime."
+
+</td>
+<td width="50%">
+
+### 🪨 Caveman (285 tokens)
+
+> "Prefer TypeScript strict mode always. No `any` unless unavoidable — comment why if used. Proper types catch bugs early."
+
+</td>
+</tr>
+</table>
+
+**Same instructions. 60% fewer tokens. Every. Single. Session.**
+
+## Security
+
+`caveman-compress` is flagged as Snyk High Risk due to subprocess and file I/O patterns detected by static analysis. This is a false positive — see [SECURITY.md](./SECURITY.md) for a full explanation of what the skill does and does not do.
+
+## Install
+
+Compress is built in with the `caveman` plugin. Install `caveman` once, then use `/caveman:compress`.
+
+If you need local files, the compress skill lives at:
+
+```bash
+caveman-compress/
+```
+
+**Requires:** Python 3.10+
+
+## Usage
+
+```
+/caveman:compress <filepath>
+```
+
+Examples:
+```
+/caveman:compress CLAUDE.md
+/caveman:compress docs/preferences.md
+/caveman:compress todos.md
+```
+
+### What files work
+
+| Type | Compress? |
+|------|-----------|
+| `.md`, `.txt`, `.rst` | ✅ Yes |
+| Extensionless natural language | ✅ Yes |
+| `.py`, `.js`, `.ts`, `.json`, `.yaml` | ❌ Skip (code/config) |
+| `*.original.md` | ❌ Skip (backup files) |
+
+## How It Work
+
+```
+/caveman:compress CLAUDE.md
+        ↓
+detect file type        (no tokens)
+        ↓
+Claude compresses       (tokens — one call)
+        ↓
+validate output         (no tokens)
+  checks: headings, code blocks, URLs, file paths, bullets
+        ↓
+if errors: Claude fixes cherry-picked issues only   (tokens — targeted fix)
+  does NOT recompress — only patches broken parts
+        ↓
+retry up to 2 times
+        ↓
+write compressed → CLAUDE.md
+write original   → CLAUDE.original.md
+```
+
+Only two things use tokens: initial compression + targeted fix if validation fails. Everything else is local Python.
+
+## What Is Preserved
+
+Caveman compress natural language. It never touch:
+
+- Code blocks (` ``` ` fenced or indented)
+- Inline code (`` `backtick content` ``)
+- URLs and links
+- File paths (`/src/components/...`)
+- Commands (`npm install`, `git commit`)
+- Technical terms, library names, API names
+- Headings (exact text preserved)
+- Tables (structure preserved, cell text compressed)
+- Dates, version numbers, numeric values
+
+## Why This Matter
+
+`CLAUDE.md` loads on **every session start**. A 1000-token project memory file costs tokens every single time you open a project. Over 100 sessions that's 100,000 tokens of overhead — just for context you already wrote.
+
+Caveman cut that by ~46% on average. Same instructions. Same accuracy. Less waste.
+
+```
+┌────────────────────────────────────────────┐
+│  TOKEN SAVINGS PER FILE    █████       46% │
+│  SESSIONS THAT BENEFIT     ██████████ 100% │
+│  INFORMATION PRESERVED     ██████████ 100% │
+│  SETUP TIME                █            1x │
+└────────────────────────────────────────────┘
+```
+
+## Part of Caveman
+
+This skill is part of the [caveman](https://github.com/JuliusBrussee/caveman) toolkit — making Claude use fewer tokens without losing accuracy.
+
+- **caveman** — make Claude *speak* like caveman (cuts response tokens ~65%)
+- **caveman-compress** — make Claude *read* less (cuts context tokens ~46%)

package/resources/skills/skills/caveman/caveman-compress/SECURITY.md

@@ -0,0 +1,31 @@
+# Security
+
+## Snyk High Risk Rating
+
+`caveman-compress` receives a Snyk High Risk rating due to static analysis heuristics. This document explains what the skill does and does not do.
+
+### What triggers the rating
+
+1. **subprocess usage**: The skill calls the `claude` CLI via `subprocess.run()` as a fallback when `ANTHROPIC_API_KEY` is not set. The subprocess call uses a fixed argument list — no shell interpolation occurs. User file content is passed via stdin, not as a shell argument.
+
+2. **File read/write**: The skill reads the file the user explicitly points it at, compresses it, and writes the result back to the same path. A `.original.md` backup is saved alongside it. No files outside the user-specified path are read or written.
+
+### What the skill does NOT do
+
+- Does not execute user file content as code
+- Does not make network requests except to Anthropic's API (via SDK or CLI)
+- Does not access files outside the path the user provides
+- Does not use shell=True or string interpolation in subprocess calls
+- Does not collect or transmit any data beyond the file being compressed
+
+### Auth behavior
+
+If `ANTHROPIC_API_KEY` is set, the skill uses the Anthropic Python SDK directly (no subprocess). If not set, it falls back to the `claude` CLI, which uses the user's existing Claude desktop authentication.
+
+### File size limit
+
+Files larger than 500KB are rejected before any API call is made.
+
+### Reporting a vulnerability
+
+If you believe you've found a genuine security issue, please open a GitHub issue with the label `security`.