chore: update skill counts to 560+ across all documentation

- Updated README.md title and descriptions from 552+ to 560+
- Updated docs/GETTING_STARTED.md references
- Updated RELEASE_NOTES.md to v4.1.0
- Removed duplicate contributor entry

.github/MAINTENANCE.md

@@ -0,0 +1,240 @@
+# 🛠️ Repository Maintenance Guide (V3)
+
+> **"If it's not documented, it's broken."**
+
+This guide details the exact procedures for maintaining `antigravity-awesome-skills`.
+It covers the **Quality Bar**, **Documentation Consistency**, and **Release Workflows**.
+
+---
+
+## 0. 🤖 Agent Protocol (THE BIBLE)
+
+**AGENTS MUST READ AND FOLLOW THIS SECTION BEFORE MARKING ANY TASK AS COMPLETE.**
+
+There are 3 things that usually fail/get forgotten. **DO NOT FORGET THEM:**
+
+### 1. 📤 ALWAYS PUSH (Non-Negotiable)
+
+Committing is NOT enough. You must PUSH to the remote.
+
+- **BAD**: `git commit -m "feat: new skill"` (User sees nothing)
+- **GOOD**: `git commit -m "..." && git push origin main`
+
+### 2. 🔄 SYNC GENERATED FILES (Avoid CI Drift)
+
+If you touch **any of these**:
+
+- `skills/` (aggiungi/rimuovi/modifichi skill)
+- la sezione **Full Skill Registry** di `README.md`
+- i **conteggi/claim** sul numero di skill (`256+ Agentic Skills...`, `(256/256)`, ecc.)
+
+…allora **DEVI** eseguire la Validation Chain **PRIMA** di committare.
+
+- Eseguire `validate_skills.py` **NON è opzionale**.
+- Eseguire `generate_index.py` **NON è opzionale**.
+- Eseguire `update_readme.py` **NON è opzionale**.
+
+Se la CI fallisce con:
+
+> `❌ Detected uncommitted changes in README.md or skills_index.json`
+
+significa che **non hai eseguito o committato** correttamente la Validation Chain.
+
+### 3. 📝 EVIDENCE OF WORK
+
+- You must create/update `walkthrough.md` or `RELEASE_NOTES.md` to document what changed.
+- If you made something new, **link it** in the artifacts.
+
+### 4. 🚫 NO BRANCHES
+
+- **ALWAYS use the `main` branch.**
+- NEVER create feature branches (e.g., `feat/new-skill`).
+- We commit directly to `main` to keep history linear and simple.
+
+---
+
+## 1. 🚦 Daily Maintenance Routine
+
+### A. Validation Chain
+
+Before ANY commit that adds/modifies skills, run the chain:
+
+1.  **Validate Metadata & Quality**:
+
+    ```bash
+    python3 scripts/validate_skills.py
+    ```
+
+    _Must return 0 errors for new skills._
+
+2.  **Regenerate Index**:
+
+    ```bash
+    python3 scripts/generate_index.py
+    ```
+
+3.  **Update Readme**:
+
+    ```bash
+    python3 scripts/update_readme.py
+    ```
+
+4.  **COMMIT GENERATED FILES**:
+    ```bash
+    git add skills_index.json README.md
+    git commit -m "chore: sync generated files"
+    ```
+    > 🔴 **CRITICAL**: If you skip this, CI will fail with "Detected uncommitted changes".
+    > See [docs/CI_DRIFT_FIX.md](../docs/CI_DRIFT_FIX.md) for details.
+
+### B. Post-Merge Routine (Must Do)
+
+After multiple PR merges or significant changes:
+
+1.  **Sync Contributors List**:
+    - Run: `git shortlog -sn --all`
+    - Update `## Repo Contributors` in README.md.
+
+2.  **Verify Table of Contents**:
+    - Ensure all new headers have clean anchors.
+    - **NO EMOJIS** in H2 headers.
+
+3.  **Draft a Release**:
+    - Go to [Releases Page](https://github.com/sickn33/antigravity-awesome-skills/releases).
+    - Draft a new release for the merged changes.
+    - Tag version (e.g., `v3.1.0`).
+
+---
+
+## 2. 📝 Documentation "Pixel Perfect" Rules
+
+We discovered several consistency issues during V3 development. Follow these rules STRICTLY.
+
+### A. Table of Contents (TOC) Anchors
+
+GitHub's anchor generation breaks if headers have emojis.
+
+- **BAD**: `## 🚀 New Here?` -> Anchor: `#--new-here` (Broken)
+- **GOOD**: `## New Here?` -> Anchor: `#new-here` (Clean)
+
+**Rule**: **NEVER put emojis in H2 (`##`) headers.** Put them in the text below if needed.
+
+### B. The "Trinity" of Docs
+
+If you update installation instructions or tool compatibility, you MUST update all 3 files:
+
+1.  `README.md` (Source of Truth)
+2.  `docs/GETTING_STARTED.md` (Beginner Guide)
+3.  `docs/FAQ.md` (Troubleshooting)
+
+_Common pitfall: Updating the clone URL in README but leaving an old one in FAQ._
+
+### C. Statistics Consistency (CRITICAL)
+
+If you add/remove skills, you **MUST** ensure the total count is identical in ALL locations.
+**Do not allow drift** (e.g., 356 in title, 354 in header).
+
+Locations to check:
+
+1.  **Title of `README.md`**: "356+ Agentic Skills..."
+2.  **`## Full Skill Registry (356/356)` header**.
+3.  **`docs/GETTING_STARTED.md` intro**.
+
+### D. Credits Policy (Who goes where?)
+
+- **Credits & Sources**: Use this for **External Repos**.
+  - _Rule_: "I extracted skills from this link you sent me." -> Add to `## Credits & Sources`.
+- **Repo Contributors**: Use this for **Pull Requests**.
+  - _Rule_: "This user sent a PR." -> Add to `## Repo Contributors`.
+
+### E. Badges & Links
+
+- **Antigravity Badge**: Must point to `https://github.com/sickn33/antigravity-awesome-skills`, NOT `anthropics/antigravity`.
+- **License**: Ensure the link points to `LICENSE` file.
+
+---
+
+## 3. 🛡️ Governance & Quality Bar
+
+### A. The 5-Point Quality Check
+
+Reject any PR that fails this:
+
+1.  **Metadata**: Has `name`, `description`?
+2.  **Safety**: `risk: offensive` used for red-team tools?
+3.  **Clarity**: Does it say _when_ to use it?
+4.  **Examples**: Copy-pasteable code blocks?
+5.  **Actions**: "Run this command" vs "Think about this".
+
+### B. Risk Labels (V3)
+
+- ⚪ **Safe**: Default.
+- 🔴 **Risk**: Destructive/Security tools. MUST have `[Authorized Use Only]` warning.
+- 🟣 **Official**: Vendor mirrors only.
+
+---
+
+## 4. 🚀 Release Workflow
+
+When cutting a new version (e.g., V4):
+
+1.  **Run Full Validation**: `python3 scripts/validate_skills.py --strict`
+2.  **Update Changelog**: Create `RELEASE_NOTES.md`.
+3.  **Bump Version**: Update header in `README.md`.
+4.  **Tag Release**:
+    ```bash
+    git tag -a v3.0.0 -m "V3 Enterprise Edition"
+    git push origin v3.0.0
+    ```
+
+### 📋 Release Note Template
+
+All changeslogs/release notes MUST follow this structure to ensure professionalism and quality:
+
+```markdown
+# Release vX.Y.Z: [Theme Name]
+
+> **[One-line catchy summary of the release]**
+
+[Brief 2-3 sentence intro about the release's impact]
+
+## 🚀 New Skills
+
+### [Emoji] [Skill Name](skills/skill-name/)
+
+**[Bold high-level benefit]**
+[Description of what it does]
+
+- **Key Feature 1**: [Detail]
+- **Key Feature 2**: [Detail]
+
+> **Try it:** `(User Prompt) ...`
+
+---
+
+## 📦 Improvements
+
+- **Registry Update**: Now tracking [N] skills.
+- **[Component]**: [Change detail]
+
+## 👥 Credits
+
+A huge shoutout to our community contributors:
+
+- **@username** for `skill-name`
+- **@username** for `fix-name`
+
+---
+
+_Upgrade now: `git pull origin main` to fetch the latest skills._
+```
+
+---
+
+## 5. 🚨 Emergency Fixes
+
+If a skill is found to be harmful or broken:
+
+1.  **Move to broken folder** (don't detect): `mv skills/bad-skill skills/.broken/`
+2.  **Or Add Warning**: Add `> [!WARNING]` to the top of `SKILL.md`.
+3.  **Push Immediately**.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,17 +1,22 @@
-## Description
+# Pull Request Description
 
-Please describe your changes. What skill are you adding or modifying?
+Please include a summary of the change and which skill is added or fixed.
 
-## Checklist
+## Quality Bar Checklist ✅
 
-- [ ] My skill follows the [creation guidelines](https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/skill-creator)
-- [ ] I have run `validate_skills.py`
-- [ ] I have added my name to the credits (if applicable)
+**All items must be checked before merging.**
+
+- [ ] **Standards**: I have read `docs/QUALITY_BAR.md` and `docs/SECURITY_GUARDRAILS.md`.
+- [ ] **Metadata**: The `SKILL.md` frontmatter is valid (checked with `scripts/validate_skills.py`).
+- [ ] **Risk Label**: I have assigned the correct `risk:` tag (`none`, `safe`, `critical`, `offensive`).
+- [ ] **Triggers**: The "When to use" section is clear and specific.
+- [ ] **Security**: If this is an _offensive_ skill, I included the "Authorized Use Only" disclaimer.
+- [ ] **Local Test**: I have verified the skill works locally.
+- [ ] **Credits**: I have added the source credit in `README.md` (if applicable).
 
 ## Type of Change
 
-- [ ] New Skill
-- [ ] Bug Fix
+- [ ] New Skill (Feature)
 - [ ] Documentation Update
 - [ ] Infrastructure
 

.github/workflows/ci.yml

@@ -0,0 +1,74 @@
+name: Skills Registry CI
+
+permissions:
+  contents: write
+
+on:
+  push:
+    branches: ["main", "feat/*"]
+  pull_request:
+    branches: ["main"]
+  workflow_dispatch:
+
+jobs:
+  validate-and-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install dependencies
+        run: |
+          pip install pyyaml
+
+      - name: 🔍 Validate Skills (Soft Mode)
+        run: |
+          python3 scripts/validate_skills.py
+
+      - name: 🏗️ Generate Index
+        run: |
+          python3 scripts/generate_index.py
+
+      - name: 📝 Update README
+        run: |
+          python3 scripts/update_readme.py
+
+      - name: Set up GitHub credentials (for auto-sync)
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        run: |
+          git config --global user.name 'github-actions[bot]'
+          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}.git
+
+      - name: Auto-commit registry drift (main only)
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        run: |
+          # Se non ci sono cambi, esci senza errore
+          git diff --quiet && exit 0
+
+          git add README.md skills_index.json || true
+
+          # Se non c'è niente da committare, esci senza errore
+          git diff --cached --quiet && exit 0
+
+          git commit -m "chore: sync generated registry files [ci skip]"
+          git push origin HEAD
+
+      - name: 🚨 Check for Uncommitted Drift
+        run: |
+          if ! git diff --quiet; then
+            echo "❌ Detected uncommitted changes produced by registry/readme scripts."
+            echo
+            echo "To fix locally, run the FULL Validation Chain, then commit and push:"
+            echo "  python3 scripts/validate_skills.py"
+            echo "  python3 scripts/generate_index.py"
+            echo "  python3 scripts/update_readme.py"
+            echo "  git add README.md skills_index.json"
+            echo "  git commit -m \"chore: sync generated registry files\""
+            echo "  git push"
+            exit 1
+          fi

.github/workflows/star-history.yml

@@ -0,0 +1,44 @@
+name: Update Star History Chart
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Daily at 06:00 UTC
+    - cron: "0 6 * * *"
+
+permissions:
+  contents: write
+
+jobs:
+  update-star-history:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install SVG renderer
+        run: |
+          set -euo pipefail
+          sudo apt-get update
+          sudo apt-get install -y librsvg2-bin
+
+      - name: Fetch latest chart (SVG) and render PNG
+        run: |
+          set -euo pipefail
+          mkdir -p assets
+          curl -fsSL \
+            "https://api.star-history.com/svg?repos=sickn33/antigravity-awesome-skills&type=date&legend=top-left" \
+            -o /tmp/star-history.svg
+          rsvg-convert /tmp/star-history.svg -o assets/star-history.png
+
+      - name: Commit and push if changed
+        run: |
+          set -euo pipefail
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add assets/star-history.png
+          if git diff --cached --quiet; then
+            echo "No changes in star-history.png"
+            exit 0
+          fi
+          git commit -m "chore: update star history chart"
+          git push

.gitignore

@@ -1,6 +1,7 @@
 
-MAINTENANCE.md
+
 walkthrough.md
 .agent/rules/
 .gemini/
 LOCAL_CONFIG.md
+data/node_modules

CATALOG.md

@@ -0,0 +1,603 @@
+# Skill Catalog
+
+Generated at: 2026-01-28T16:10:28.837Z
+
+Total skills: 552
+
+## architecture (52)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `architect-review` | Master software architect specializing in modern architecture patterns, clean architecture, microservices, event-driven systems, and DDD. Reviews system desi... |  | architect, review, software, specializing, architecture, clean, microservices, event, driven, ddd, reviews, designs |
+| `architecture` | Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing ... | architecture | architecture, architectural, decision, making, framework, requirements, analysis, trade, off, evaluation, adr, documentation |
+| `architecture-decision-records` | Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant techn... | architecture, decision, records | architecture, decision, records, write, maintain, adrs, following, technical, documentation, documenting, significant, decisions |
+| `avalonia-viewmodels-zafiro` | Optimal ViewModel and Wizard creation patterns for Avalonia using Zafiro and ReactiveUI. | avalonia, viewmodels, zafiro | avalonia, viewmodels, zafiro, optimal, viewmodel, wizard, creation, reactiveui |
+| `bash-linux` | Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems. | bash, linux | bash, linux, terminal, critical, commands, piping, error, handling, scripting, working, macos |
+| `binary-analysis-patterns` | Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, un... | binary | binary, analysis, including, disassembly, decompilation, control, flow, code, recognition, analyzing, executables, understanding |
+| `brainstorming` | Use this skill before any creative or constructive work (features, components, architecture, behavior changes, or functionality). This skill transforms vague... | brainstorming | brainstorming, skill, before, any, creative, constructive, work, features, components, architecture, behavior, changes |
+| `browser-extension-builder` | Expert in building browser extensions that solve real problems - Chrome, Firefox, and cross-browser extensions. Covers extension architecture, manifest v3, c... | browser, extension, builder | browser, extension, builder, building, extensions, solve, real, problems, chrome, firefox, cross, covers |
+| `c4-architecture-c4-architecture` | Generate comprehensive C4 architecture documentation for an existing repository/codebase using a bottom-up analysis approach. | c4, architecture | c4, architecture, generate, documentation, existing, repository, codebase, bottom, up, analysis, approach |
+| `c4-code` | Expert C4 Code-level documentation specialist. Analyzes code directories to create comprehensive C4 code-level documentation including function signatures, a... | c4, code | c4, code, level, documentation, analyzes, directories, including, function, signatures, arguments, dependencies, structure |
+| `c4-component` | Expert C4 Component-level documentation specialist. Synthesizes C4 Code-level documentation into Component-level architecture, defining component boundaries,... | c4, component | c4, component, level, documentation, synthesizes, code, architecture, defining, boundaries, interfaces, relationships, creates |
+| `c4-context` | Expert C4 Context-level documentation specialist. Creates high-level system context diagrams, documents personas, user journeys, system features, and externa... | c4 | c4, context, level, documentation, creates, high, diagrams, documents, personas, user, journeys, features |
+| `code-refactoring-refactor-clean` | You are a code refactoring expert specializing in clean code principles, SOLID design patterns, and modern software engineering best practices. Analyze and r... | code, refactoring, refactor, clean | code, refactoring, refactor, clean, specializing, principles, solid, software, engineering, analyze, provided, improve |
+| `codebase-cleanup-refactor-clean` | You are a code refactoring expert specializing in clean code principles, SOLID design patterns, and modern software engineering best practices. Analyze and r... | codebase, cleanup, refactor, clean | codebase, cleanup, refactor, clean, code, refactoring, specializing, principles, solid, software, engineering, analyze |
+| `competitor-alternatives` | When the user wants to create competitor comparison or alternative pages for SEO and sales enablement. Also use when the user mentions 'alternative page,' 'v... | competitor, alternatives | competitor, alternatives, user, wants, comparison, alternative, pages, seo, sales, enablement, mentions, page |
+| `core-components` | Core component library and design system patterns. Use when building UI, using design tokens, or working with the component library. | core, components | core, components, component, library, building, ui, tokens, working |
+| `cpp-pro` | Write idiomatic C++ code with modern features, RAII, smart pointers, and STL algorithms. Handles templates, move semantics, and performance optimization. Use... | cpp | cpp, pro, write, idiomatic, code, features, raii, smart, pointers, stl, algorithms, move |
+| `cqrs-implementation` | Implement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or bu... | cqrs | cqrs, command, query, responsibility, segregation, scalable, architectures, separating, read, write, models, optimizing |
+| `doc-coauthoring` | Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision do... | doc, coauthoring | doc, coauthoring, users, through, structured, co, authoring, documentation, user, wants, write, proposals |
+| `docs-architect` | Creates comprehensive technical documentation from existing codebases. Analyzes architecture, design patterns, and implementation details to produce long-for... | docs | docs, architect, creates, technical, documentation, existing, codebases, analyzes, architecture, details, produce, long |
+| `elixir-pro` | Write idiomatic Elixir code with OTP patterns, supervision trees, and Phoenix LiveView. Masters concurrency, fault tolerance, and distributed systems. Use PR... | elixir | elixir, pro, write, idiomatic, code, otp, supervision, trees, phoenix, liveview, masters, concurrency |
+| `email-systems` | Email has the highest ROI of any marketing channel. $36 for every $1 spent. Yet most startups treat it as an afterthought - bulk blasts, no personalization, ... | email | email, highest, roi, any, marketing, channel, 36, every, spent, yet, most, startups |
+| `error-detective` | Search logs and codebases for error patterns, stack traces, and anomalies. Correlates errors across systems and identifies root causes. Use PROACTIVELY when ... | error, detective | error, detective, search, logs, codebases, stack, traces, anomalies, correlates, errors, identifies, root |
+| `error-handling-patterns` | Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applicatio... | error, handling | error, handling, languages, including, exceptions, result, types, propagation, graceful, degradation, resilient, applications |
+| `event-sourcing-architect` | Expert in event sourcing, CQRS, and event-driven architecture patterns. Masters event store design, projection building, saga orchestration, and eventual con... | event, sourcing | event, sourcing, architect, cqrs, driven, architecture, masters, store, projection, building, saga, orchestration |
+| `event-store-design` | Design and implement event stores for event-sourced systems. Use when building event sourcing infrastructure, choosing event store technologies, or implement... | event, store | event, store, stores, sourced, building, sourcing, infrastructure, choosing, technologies, implementing, persistence |
+| `godot-gdscript-patterns` | Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization. Use when building Godot games, implementing game systems, or le... | godot, gdscript | godot, gdscript, including, signals, scenes, state, machines, optimization, building, games, implementing, game |
+| `haskell-pro` | Expert Haskell engineer specializing in advanced type systems, pure functional design, and high-reliability software. Use PROACTIVELY for type-level programm... | haskell | haskell, pro, engineer, specializing, type, pure, functional, high, reliability, software, proactively, level |
+| `i18n-localization` | Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support. | i18n, localization | i18n, localization, internationalization, detecting, hardcoded, strings, managing, translations, locale, files, rtl |
+| `inngest` | Inngest expert for serverless-first background jobs, event-driven workflows, and durable execution without managing queues or workers. Use when: inngest, ser... | inngest | inngest, serverless, first, background, jobs, event, driven, durable, execution, without, managing, queues |
+| `julia-pro` | Master Julia 1.10+ with modern features, performance optimization, multiple dispatch, and production-ready practices. Expert in the Julia ecosystem including... | julia | julia, pro, 10, features, performance, optimization, multiple, dispatch, ecosystem, including, package, scientific |
+| `minecraft-bukkit-pro` | Master Minecraft server plugin development with Bukkit, Spigot, and Paper APIs. Specializes in event-driven architecture, command systems, world manipulation... | minecraft, bukkit | minecraft, bukkit, pro, server, plugin, development, spigot, paper, apis, specializes, event, driven |
+| `monorepo-architect` | Expert in monorepo architecture, build systems, and dependency management at scale. Masters Nx, Turborepo, Bazel, and Lerna for efficient multi-project devel... | monorepo | monorepo, architect, architecture, dependency, scale, masters, nx, turborepo, bazel, lerna, efficient, multi |
+| `nestjs-expert` | Nest.js framework expert specializing in module architecture, dependency injection, middleware, guards, interceptors, testing with Jest/Supertest, TypeORM/Mo... | nestjs | nestjs, nest, js, framework, specializing, module, architecture, dependency, injection, middleware, guards, interceptors |
+| `nx-workspace-patterns` | Configure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected com... | nx, workspace | nx, workspace, configure, optimize, monorepo, workspaces, setting, up, configuring, boundaries, optimizing, caching |
+| `on-call-handoff-patterns` | Master on-call shift handoffs with context transfer, escalation procedures, and documentation. Use when transitioning on-call responsibilities, documenting s... | on, call, handoff | on, call, handoff, shift, handoffs, context, transfer, escalation, procedures, documentation, transitioning, responsibilities |
+| `parallel-agents` | Multi-agent orchestration patterns. Use when multiple independent tasks can run with different domain expertise or when comprehensive analysis requires multi... | parallel, agents | parallel, agents, multi, agent, orchestration, multiple, independent, tasks, run, different, domain, expertise |
+| `powershell-windows` | PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling. | powershell, windows | powershell, windows, critical, pitfalls, operator, syntax, error, handling |
+| `production-code-audit` | Autonomously deep-scan entire codebase line-by-line, understand architecture and patterns, then systematically transform it to production-grade, corporate-le... | production, code, audit | production, code, audit, autonomously, deep, scan, entire, codebase, line, understand, architecture, then |
+| `projection-patterns` | Build read models and projections from event streams. Use when implementing CQRS read sides, building materialized views, or optimizing query performance in ... | projection | projection, read, models, projections, event, streams, implementing, cqrs, sides, building, materialized, views |
+| `prompt-engineering` | Expert guide on prompt engineering patterns, best practices, and optimization techniques. Use when user wants to improve prompts, learn prompting strategies,... | prompt, engineering | prompt, engineering, optimization, techniques, user, wants, improve, prompts, learn, prompting, debug, agent |
+| `saga-orchestration` | Implement saga patterns for distributed transactions and cross-aggregate workflows. Use when coordinating multi-step business processes, handling compensatin... | saga | saga, orchestration, distributed, transactions, cross, aggregate, coordinating, multi, step, business, processes, handling |
+| `salesforce-development` | Expert patterns for Salesforce platform development including Lightning Web Components (LWC), Apex triggers and classes, REST/Bulk APIs, Connected Apps, and ... | salesforce | salesforce, development, platform, including, lightning, web, components, lwc, apex, triggers, classes, rest |
+| `skill-developer` | Create and manage Claude Code skills following Anthropic best practices. Use when creating new skills, modifying skill-rules.json, understanding trigger patt... | skill | skill, developer, claude, code, skills, following, anthropic, creating, new, modifying, rules, json |
+| `software-architecture` | Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that... | software, architecture | software, architecture, quality, skill, should, used, users, want, write, code, analyze, any |
+| `tailwind-design-system` | Build scalable design systems with Tailwind CSS, design tokens, component libraries, and responsive patterns. Use when creating component libraries, implemen... | tailwind | tailwind, scalable, css, tokens, component, libraries, responsive, creating, implementing, standardizing, ui |
+| `tailwind-patterns` | Tailwind CSS v4 principles. CSS-first configuration, container queries, modern patterns, design token architecture. | tailwind | tailwind, css, v4, principles, first, configuration, container, queries, token, architecture |
+| `testing-patterns` | Jest testing patterns, factory functions, mocking strategies, and TDD workflow. Use when writing unit tests, creating test factories, or following TDD red-gr... |  | testing, jest, factory, functions, mocking, tdd, writing, unit, tests, creating, test, factories |
+| `wcag-audit-patterns` | Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility, fi... | wcag, audit | wcag, audit, conduct, accessibility, audits, automated, testing, manual, verification, remediation, guidance, auditing |
+| `workflow-orchestration-patterns` | Design durable workflows with Temporal for distributed systems. Covers workflow vs activity separation, saga patterns, state management, and determinism cons... |  | orchestration, durable, temporal, distributed, covers, vs, activity, separation, saga, state, determinism, constraints |
+| `workflow-patterns` | Use this skill when implementing tasks according to Conductor's TDD workflow, handling phase checkpoints, managing git commits for tasks, or understanding th... |  | skill, implementing, tasks, according, conductor, tdd, handling, phase, checkpoints, managing, git, commits |
+| `zapier-make-patterns` | No-code automation democratizes workflow building. Zapier and Make (formerly Integromat) let non-developers automate business processes without writing code.... | zapier, make | zapier, make, no, code, automation, democratizes, building, formerly, integromat, let, non, developers |
+
+## business (35)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `competitive-landscape` | This skill should be used when the user asks to "analyze competitors", "assess competitive landscape", "identify differentiation", "evaluate market positioni... | competitive, landscape | competitive, landscape, skill, should, used, user, asks, analyze, competitors, assess, identify, differentiation |
+| `conductor-setup` | Initialize project with Conductor artifacts (product definition, tech stack, workflow, style guides) | conductor, setup | conductor, setup, initialize, artifacts, product, definition, tech, stack, style, guides |
+| `content-creator` | Create SEO-optimized marketing content with consistent brand voice. Includes brand voice analyzer, SEO optimizer, content frameworks, and social media templa... | content, creator | content, creator, seo, optimized, marketing, consistent, brand, voice, includes, analyzer, optimizer, frameworks |
+| `context-driven-development` | Use this skill when working with Conductor's context-driven development methodology, managing project context artifacts, or understanding the relationship be... | driven | driven, context, development, skill, working, conductor, methodology, managing, artifacts, understanding, relationship, between |
+| `copy-editing` | When the user wants to edit, review, or improve existing marketing copy. Also use when the user mentions 'edit this copy,' 'review my copy,' 'copy feedback,'... | copy, editing | copy, editing, user, wants, edit, review, improve, existing, marketing, mentions, my, feedback |
+| `copywriting` | Use this skill when writing, rewriting, or improving marketing copy for any page (homepage, landing page, pricing, feature, product, or about page). This ski... | copywriting | copywriting, skill, writing, rewriting, improving, marketing, copy, any, page, homepage, landing, pricing |
+| `defi-protocol-templates` | Implement DeFi protocols with production-ready templates for staking, AMMs, governance, and lending systems. Use when building decentralized finance applicat... | defi, protocol | defi, protocol, protocols, staking, amms, governance, lending, building, decentralized, finance, applications, smart |
+| `employment-contract-templates` | Create employment contracts, offer letters, and HR policy documents following legal best practices. Use when drafting employment agreements, creating HR poli... | employment, contract | employment, contract, contracts, offer, letters, hr, policy, documents, following, legal, drafting, agreements |
+| `framework-migration-legacy-modernize` | Orchestrate a comprehensive legacy system modernization using the strangler fig pattern, enabling gradual replacement of outdated components while maintainin... | framework, migration, legacy, modernize | framework, migration, legacy, modernize, orchestrate, modernization, strangler, fig, enabling, gradual, replacement, outdated |
+| `free-tool-strategy` | When the user wants to plan, evaluate, or build a free tool for marketing purposes — lead generation, SEO value, or brand awareness. Also use when the user m... | free | free, user, wants, plan, evaluate, marketing, purposes, lead, generation, seo, value, brand |
+| `hr-pro` | Professional, ethical HR partner for hiring, onboarding/offboarding, PTO and leave, performance, compliant policies, and employee relations. Ask for jurisdic... | hr | hr, pro, professional, ethical, partner, hiring, onboarding, offboarding, pto, leave, performance, compliant |
+| `market-sizing-analysis` | This skill should be used when the user asks to "calculate TAM", "determine SAM", "estimate SOM", "size the market", "calculate market opportunity", "what's ... | market, sizing | market, sizing, analysis, skill, should, used, user, asks, calculate, tam, determine, sam |
+| `marketing-ideas` | Provide proven marketing strategies and growth ideas for SaaS and software products, prioritized using a marketing feasibility scoring system. | marketing, ideas | marketing, ideas, provide, proven, growth, saas, software, products, prioritized, feasibility, scoring |
+| `marketing-psychology` | Apply behavioral science and mental models to marketing decisions, prioritized using a psychological leverage and feasibility scoring system. | marketing, psychology | marketing, psychology, apply, behavioral, science, mental, models, decisions, prioritized, psychological, leverage, feasibility |
+| `notion-template-business` | Expert in building and selling Notion templates as a business - not just making templates, but building a sustainable digital product business. Covers templa... | notion, business | notion, business, building, selling, just, making, sustainable, digital, product, covers, pricing, marketplaces |
+| `page-cro` | Analyze and optimize individual pages for conversion performance. Use when the user wants to improve conversion rates, diagnose why a page is underperforming... | page, cro | page, cro, analyze, optimize, individual, pages, conversion, performance, user, wants, improve, rates |
+| `paywall-upgrade-cro` | When the user wants to create or optimize in-app paywalls, upgrade screens, upsell modals, or feature gates. Also use when the user mentions "paywall," "upgr... | paywall, upgrade, cro | paywall, upgrade, cro, user, wants, optimize, app, paywalls, screens, upsell, modals, feature |
+| `pricing-strategy` | Design pricing, packaging, and monetization strategies based on value, customer willingness to pay, and growth objectives. | pricing | pricing, packaging, monetization, value, customer, willingness, pay, growth, objectives |
+| `sales-automator` | Draft cold emails, follow-ups, and proposal templates. Creates pricing pages, case studies, and sales scripts. Use PROACTIVELY for sales outreach or lead nur... | sales, automator | sales, automator, draft, cold, emails, follow, ups, proposal, creates, pricing, pages, case |
+| `scroll-experience` | Expert in building immersive scroll-driven experiences - parallax storytelling, scroll animations, interactive narratives, and cinematic web experiences. Lik... | scroll, experience | scroll, experience, building, immersive, driven, experiences, parallax, storytelling, animations, interactive, narratives, cinematic |
+| `seo-cannibalization-detector` | Analyzes multiple provided pages to identify keyword overlap and potential cannibalization issues. Suggests differentiation strategies. Use PROACTIVELY when ... | seo, cannibalization, detector | seo, cannibalization, detector, analyzes, multiple, provided, pages, identify, keyword, overlap, potential, issues |
+| `seo-content-auditor` | Analyzes provided content for quality, E-E-A-T signals, and SEO best practices. Scores content and provides improvement recommendations based on established ... | seo, content, auditor | seo, content, auditor, analyzes, provided, quality, signals, scores, provides, improvement, recommendations, established |
+| `seo-content-planner` | Creates comprehensive content outlines and topic clusters for SEO. Plans content calendars and identifies topic gaps. Use PROACTIVELY for content strategy an... | seo, content, planner | seo, content, planner, creates, outlines, topic, clusters, plans, calendars, identifies, gaps, proactively |
+| `seo-content-refresher` | Identifies outdated elements in provided content and suggests updates to maintain freshness. Finds statistics, dates, and examples that need updating. Use PR... | seo, content, refresher | seo, content, refresher, identifies, outdated, elements, provided, suggests, updates, maintain, freshness, finds |
+| `seo-content-writer` | Writes SEO-optimized content based on provided keywords and topic briefs. Creates engaging, comprehensive content following best practices. Use PROACTIVELY f... | seo, content, writer | seo, content, writer, writes, optimized, provided, keywords, topic, briefs, creates, engaging, following |
+| `seo-fundamentals` | Core principles of SEO including E-E-A-T, Core Web Vitals, technical foundations, content quality, and how modern search engines evaluate pages. This skill e... | seo, fundamentals | seo, fundamentals, core, principles, including, web, vitals, technical, foundations, content, quality, how |
+| `seo-keyword-strategist` | Analyzes keyword usage in provided content, calculates density, suggests semantic variations and LSI keywords based on the topic. Prevents over-optimization.... | seo, keyword, strategist | seo, keyword, strategist, analyzes, usage, provided, content, calculates, density, suggests, semantic, variations |
+| `seo-meta-optimizer` | Creates optimized meta titles, descriptions, and URL suggestions based on character limits and best practices. Generates compelling, keyword-rich metadata. U... | seo, meta, optimizer | seo, meta, optimizer, creates, optimized, titles, descriptions, url, suggestions, character, limits, generates |
+| `seo-snippet-hunter` | Formats content to be eligible for featured snippets and SERP features. Creates snippet-optimized content blocks based on best practices. Use PROACTIVELY for... | seo, snippet, hunter | seo, snippet, hunter, formats, content, eligible, featured, snippets, serp, features, creates, optimized |
+| `seo-structure-architect` | Analyzes and optimizes content structure including header hierarchy, suggests schema markup, and internal linking opportunities. Creates search-friendly cont... | seo, structure | seo, structure, architect, analyzes, optimizes, content, including, header, hierarchy, suggests, schema, markup |
+| `startup-business-analyst-business-case` | Generate comprehensive investor-ready business case document with market, solution, financials, and strategy | startup, business, analyst, case | startup, business, analyst, case, generate, investor, document, market, solution, financials |
+| `startup-business-analyst-financial-projections` | Create detailed 3-5 year financial model with revenue, costs, cash flow, and scenarios | startup, business, analyst, financial, projections | startup, business, analyst, financial, projections, detailed, year, model, revenue, costs, cash, flow |
+| `startup-business-analyst-market-opportunity` | Generate comprehensive market opportunity analysis with TAM/SAM/SOM calculations | startup, business, analyst, market, opportunity | startup, business, analyst, market, opportunity, generate, analysis, tam, sam, som, calculations |
+| `startup-financial-modeling` | This skill should be used when the user asks to "create financial projections", "build a financial model", "forecast revenue", "calculate burn rate", "estima... | startup, financial, modeling | startup, financial, modeling, skill, should, used, user, asks, projections, model, forecast, revenue |
+| `team-composition-analysis` | This skill should be used when the user asks to "plan team structure", "determine hiring needs", "design org chart", "calculate compensation", "plan equity a... | team, composition | team, composition, analysis, skill, should, used, user, asks, plan, structure, determine, hiring |
+
+## data-ai (81)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `agent-memory-mcp` | A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions). | agent, memory, mcp | agent, memory, mcp, hybrid, provides, persistent, searchable, knowledge, ai, agents, architecture, decisions |
+| `agent-tool-builder` | Tools are how AI agents interact with the world. A well-designed tool is the difference between an agent that works and one that hallucinates, fails silently... | agent, builder | agent, builder, how, ai, agents, interact, world, well, designed, difference, between, works |
+| `ai-agents-architect` | Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build ... | ai, agents | ai, agents, architect, designing, building, autonomous, masters, memory, planning, multi, agent, orchestration |
+| `ai-engineer` | Build production-ready LLM applications, advanced RAG systems, and intelligent agents. Implements vector search, multimodal AI, agent orchestration, and ente... | ai | ai, engineer, llm, applications, rag, intelligent, agents, implements, vector, search, multimodal, agent |
+| `ai-wrapper-product` | Expert in building products that wrap AI APIs (OpenAI, Anthropic, etc.) into focused tools people will pay for. Not just 'ChatGPT but different' - products t... | ai, wrapper, product | ai, wrapper, product, building, products, wrap, apis, openai, anthropic, etc, people, pay |
+| `analytics-tracking` | Design, audit, and improve analytics tracking systems that produce reliable, decision-ready data. Use when the user wants to set up, fix, or evaluate analyti... | analytics, tracking | analytics, tracking, audit, improve, produce, reliable, decision, data, user, wants, set, up |
+| `api-documenter` | Master API documentation with OpenAPI 3.1, AI-powered tools, and modern developer experience practices. Create interactive docs, generate SDKs, and build com... | api, documenter | api, documenter, documentation, openapi, ai, powered, developer, experience, interactive, docs, generate, sdks |
+| `autonomous-agent-patterns` | Design patterns for building autonomous coding agents. Covers tool integration, permission systems, browser automation, and human-in-the-loop workflows. Use ... | autonomous, agent | autonomous, agent, building, coding, agents, covers, integration, permission, browser, automation, human, loop |
+| `autonomous-agents` | Autonomous agents are AI systems that can independently decompose goals, plan actions, execute tools, and self-correct without constant human guidance. The c... | autonomous, agents | autonomous, agents, ai, independently, decompose, goals, plan, actions, execute, self, correct, without |
+| `behavioral-modes` | AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type. | behavioral, modes | behavioral, modes, ai, operational, brainstorm, debug, review, teach, ship, orchestrate, adapt, behavior |
+| `blockrun` | Use when user needs capabilities Claude lacks (image generation, real-time X/Twitter data) or explicitly requests external models ("blockrun", "use grok", "u... | blockrun | blockrun, user, capabilities, claude, lacks, image, generation, real, time, twitter, data, explicitly |
+| `browser-automation` | Browser automation powers web testing, scraping, and AI agent interactions. The difference between a flaky script and a reliable system comes down to underst... | browser | browser, automation, powers, web, testing, scraping, ai, agent, interactions, difference, between, flaky |
+| `business-analyst` | Master modern business analysis with AI-powered analytics, real-time dashboards, and data-driven insights. Build comprehensive KPI frameworks, predictive mod... | business, analyst | business, analyst, analysis, ai, powered, analytics, real, time, dashboards, data, driven, insights |
+| `cc-skill-backend-patterns` | Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes. | cc, skill, backend | cc, skill, backend, architecture, api, database, optimization, server, side, node, js, express |
+| `cc-skill-clickhouse-io` | ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads. | cc, skill, clickhouse, io | cc, skill, clickhouse, io, database, query, optimization, analytics, data, engineering, high, performance |
+| `code-documentation-doc-generate` | You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user g... | code, documentation, doc, generate | code, documentation, doc, generate, specializing, creating, maintainable, api, docs, architecture, diagrams, user |
+| `codex-review` | Professional code review with auto CHANGELOG generation, integrated with Codex AI | codex | codex, review, professional, code, auto, changelog, generation, integrated, ai |
+| `content-marketer` | Elite content marketing strategist specializing in AI-powered content creation, omnichannel distribution, SEO optimization, and data-driven performance marke... | content, marketer | content, marketer, elite, marketing, strategist, specializing, ai, powered, creation, omnichannel, distribution, seo |
+| `context-manager` | Elite AI context engineering specialist mastering dynamic context management, vector databases, knowledge graphs, and intelligent memory systems. Orchestrate... | manager | manager, context, elite, ai, engineering, mastering, dynamic, vector, databases, knowledge, graphs, intelligent |
+| `context-window-management` | Strategies for managing LLM context windows including summarization, trimming, routing, and avoiding context rot Use when: context window, token limit, conte... | window | window, context, managing, llm, windows, including, summarization, trimming, routing, avoiding, rot, token |
+| `conversation-memory` | Persistent memory systems for LLM conversations including short-term, long-term, and entity-based memory Use when: conversation memory, remember, memory pers... | conversation, memory | conversation, memory, persistent, llm, conversations, including, short, term, long, entity, remember, persistence |
+| `crewai` | Expert in CrewAI - the leading role-based multi-agent framework used by 60% of Fortune 500 companies. Covers agent design with roles and goals, task definiti... | crewai | crewai, leading, role, multi, agent, framework, used, 60, fortune, 500, companies, covers |
+| `customer-support` | Elite AI-powered customer support specialist mastering conversational AI, automated ticketing, sentiment analysis, and omnichannel support experiences. Integ... | customer, support | customer, support, elite, ai, powered, mastering, conversational, automated, ticketing, sentiment, analysis, omnichannel |
+| `data-engineering-data-driven-feature` | Build features guided by data insights, A/B testing, and continuous measurement using specialized agents for analysis, implementation, and experimentation. | data, engineering, driven | data, engineering, driven, feature, features, guided, insights, testing, continuous, measurement, specialized, agents |
+| `data-quality-frameworks` | Implement data quality validation with Great Expectations, dbt tests, and data contracts. Use when building data quality pipelines, implementing validation r... | data, quality, frameworks | data, quality, frameworks, validation, great, expectations, dbt, tests, contracts, building, pipelines, implementing |
+| `data-scientist` | Expert data scientist for advanced analytics, machine learning, and statistical modeling. Handles complex data analysis, predictive modeling, and business in... | data, scientist | data, scientist, analytics, machine, learning, statistical, modeling, complex, analysis, predictive, business, intelligence |
+| `data-storytelling` | Transform data into compelling narratives using visualization, context, and persuasive structure. Use when presenting analytics to stakeholders, creating dat... | data, storytelling | data, storytelling, transform, compelling, narratives, visualization, context, persuasive, structure, presenting, analytics, stakeholders |
+| `database-architect` | Expert database architect specializing in data layer design from scratch, technology selection, schema modeling, and scalable database architectures. Masters... | database | database, architect, specializing, data, layer, scratch, technology, selection, schema, modeling, scalable, architectures |
+| `database-design` | Database design principles and decision-making. Schema design, indexing strategy, ORM selection, serverless databases. | database | database, principles, decision, making, schema, indexing, orm, selection, serverless, databases |
+| `dbt-transformation-patterns` | Master dbt (data build tool) for analytics engineering with model organization, testing, documentation, and incremental strategies. Use when building data tr... | dbt, transformation | dbt, transformation, data, analytics, engineering, model, organization, testing, documentation, incremental, building, transformations |
+| `documentation-generation-doc-generate` | You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user g... | documentation, generation, doc, generate | documentation, generation, doc, generate, specializing, creating, maintainable, code, api, docs, architecture, diagrams |
+| `documentation-templates` | Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation. | documentation | documentation, structure, guidelines, readme, api, docs, code, comments, ai, friendly |
+| `embedding-strategies` | Select and optimize embedding models for semantic search and RAG applications. Use when choosing embedding models, implementing chunking strategies, or optim... | embedding, strategies | embedding, strategies, select, optimize, models, semantic, search, rag, applications, choosing, implementing, chunking |
+| `frontend-dev-guidelines` | Opinionated frontend development standards for modern React + TypeScript applications. Covers Suspense-first data fetching, lazy loading, feature-based archi... | frontend, dev, guidelines | frontend, dev, guidelines, opinionated, development, standards, react, typescript, applications, covers, suspense, first |
+| `geo-fundamentals` | Generative Engine Optimization for AI search engines (ChatGPT, Claude, Perplexity). | geo, fundamentals | geo, fundamentals, generative, engine, optimization, ai, search, engines, chatgpt, claude, perplexity |
+| `graphql` | GraphQL gives clients exactly the data they need - no more, no less. One endpoint, typed schema, introspection. But the flexibility that makes it powerful al... | graphql | graphql, gives, clients, exactly, data, no, less, one, endpoint, typed, schema, introspection |
+| `hybrid-search-implementation` | Combine vector and keyword search for improved retrieval. Use when implementing RAG systems, building search engines, or when neither approach alone provides... | hybrid, search | hybrid, search, combine, vector, keyword, improved, retrieval, implementing, rag, building, engines, neither |
+| `ios-developer` | Develop native iOS applications with Swift/SwiftUI. Masters iOS 18, SwiftUI, UIKit integration, Core Data, networking, and App Store optimization. Use PROACT... | ios | ios, developer, develop, native, applications, swift, swiftui, masters, 18, uikit, integration, core |
+| `langchain-architecture` | Design LLM applications using the LangChain framework with agents, memory, and tool integration patterns. Use when building LangChain applications, implement... | langchain, architecture | langchain, architecture, llm, applications, framework, agents, memory, integration, building, implementing, ai, creating |
+| `langgraph` | Expert in LangGraph - the production-grade framework for building stateful, multi-actor AI applications. Covers graph construction, state management, cycles ... | langgraph | langgraph, grade, framework, building, stateful, multi, actor, ai, applications, covers, graph, construction |
+| `llm-application-dev-ai-assistant` | You are an AI assistant development expert specializing in creating intelligent conversational interfaces, chatbots, and AI-powered applications. Design comp... | llm, application, dev, ai | llm, application, dev, ai, assistant, development, specializing, creating, intelligent, conversational, interfaces, chatbots |
+| `llm-application-dev-langchain-agent` | You are an expert LangChain agent developer specializing in production-grade AI systems using LangChain 0.1+ and LangGraph. | llm, application, dev, langchain, agent | llm, application, dev, langchain, agent, developer, specializing, grade, ai, langgraph |
+| `llm-application-dev-prompt-optimize` | You are an expert prompt engineer specializing in crafting effective prompts for LLMs through advanced techniques including constitutional AI, chain-of-thoug... | llm, application, dev, prompt, optimize | llm, application, dev, prompt, optimize, engineer, specializing, crafting, effective, prompts, llms, through |
+| `llm-evaluation` | Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performanc... | llm, evaluation | llm, evaluation, applications, automated, metrics, human, feedback, benchmarking, testing, performance, measuring, ai |
+| `neon-postgres` | Expert patterns for Neon serverless Postgres, branching, connection pooling, and Prisma/Drizzle integration Use when: neon database, serverless postgres, dat... | neon, postgres | neon, postgres, serverless, branching, connection, pooling, prisma, drizzle, integration, database |
+| `nextjs-app-router-patterns` | Master Next.js 14+ App Router with Server Components, streaming, parallel routes, and advanced data fetching. Use when building Next.js applications, impleme... | nextjs, app, router | nextjs, app, router, next, js, 14, server, components, streaming, parallel, routes, data |
+| `nextjs-best-practices` | Next.js App Router principles. Server Components, data fetching, routing patterns. | nextjs, best, practices | nextjs, best, practices, next, js, app, router, principles, server, components, data, fetching |
+| `nodejs-backend-patterns` | Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration,... | nodejs, backend | nodejs, backend, node, js, express, fastify, implementing, middleware, error, handling, authentication, database |
+| `php-pro` | Write idiomatic PHP code with generators, iterators, SPL data structures, and modern OOP features. Use PROACTIVELY for high-performance PHP applications. | php | php, pro, write, idiomatic, code, generators, iterators, spl, data, structures, oop, features |
+| `postgres-best-practices` | Postgres performance optimization and best practices from Supabase. Use this skill when writing, reviewing, or optimizing Postgres queries, schema designs, o... | postgres, best, practices | postgres, best, practices, supabase, performance, optimization, skill, writing, reviewing, optimizing, queries, schema |
+| `postgresql` | Design a PostgreSQL-specific schema. Covers best-practices, data types, indexing, constraints, performance patterns, and advanced features | postgresql | postgresql, specific, schema, covers, data, types, indexing, constraints, performance, features |
+| `prisma-expert` | Prisma ORM expert for schema design, migrations, query optimization, relations modeling, and database operations. Use PROACTIVELY for Prisma schema issues, m... | prisma | prisma, orm, schema, migrations, query, optimization, relations, modeling, database, operations, proactively, issues |
+| `programmatic-seo` | Design and evaluate programmatic SEO strategies for creating SEO-driven pages at scale using templates and structured data. Use when the user mentions progra... | programmatic, seo | programmatic, seo, evaluate, creating, driven, pages, scale, structured, data, user, mentions, directory |
+| `prompt-caching` | Caching strategies for LLM prompts including Anthropic prompt caching, response caching, and CAG (Cache Augmented Generation) Use when: prompt caching, cache... | prompt, caching | prompt, caching, llm, prompts, including, anthropic, response, cag, cache, augmented, generation |
+| `prompt-engineer` | Expert prompt engineer specializing in advanced prompting techniques, LLM optimization, and AI system design. Masters chain-of-thought, constitutional AI, an... | prompt | prompt, engineer, specializing, prompting, techniques, llm, optimization, ai, masters, chain, thought, constitutional |
+| `prompt-engineering-patterns` | Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Use when optimizing prompts, impro... | prompt, engineering | prompt, engineering, techniques, maximize, llm, performance, reliability, controllability, optimizing, prompts, improving, outputs |
+| `rag-engineer` | Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LL... | rag | rag, engineer, building, retrieval, augmented, generation, masters, embedding, models, vector, databases, chunking |
+| `rag-implementation` | Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded A... | rag | rag, retrieval, augmented, generation, llm, applications, vector, databases, semantic, search, implementing, knowledge |
+| `react-best-practices` | React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.j... | react, best, practices | react, best, practices, vercel, next, js, performance, optimization, guidelines, engineering, skill, should |
+| `react-ui-patterns` | Modern React UI patterns for loading states, error handling, and data fetching. Use when building UI components, handling async data, or managing UI states. | react, ui | react, ui, loading, states, error, handling, data, fetching, building, components, async, managing |
+| `scala-pro` | Master enterprise-grade Scala development with functional programming, distributed systems, and big data processing. Expert in Apache Pekko, Akka, Spark, ZIO... | scala | scala, pro, enterprise, grade, development, functional, programming, distributed, big, data, processing, apache |
+| `schema-markup` | Design, validate, and optimize schema.org structured data for eligibility, correctness, and measurable SEO impact. Use when the user wants to add, fix, audit... | schema, markup | schema, markup, validate, optimize, org, structured, data, eligibility, correctness, measurable, seo, impact |
+| `segment-cdp` | Expert patterns for Segment Customer Data Platform including Analytics.js, server-side tracking, tracking plans with Protocols, identity resolution, destinat... | segment, cdp | segment, cdp, customer, data, platform, including, analytics, js, server, side, tracking, plans |
+| `senior-architect` | Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin, F... | senior | senior, architect, software, architecture, skill, designing, scalable, maintainable, reactjs, nextjs, nodejs, express |
+| `seo-audit` | Diagnose and audit SEO issues affecting crawlability, indexation, rankings, and organic performance. Use when the user asks for an SEO audit, technical SEO r... | seo, audit | seo, audit, diagnose, issues, affecting, crawlability, indexation, rankings, organic, performance, user, asks |
+| `similarity-search-patterns` | Implement efficient similarity search with vector databases. Use when building semantic search, implementing nearest neighbor queries, or optimizing retrieva... | similarity, search | similarity, search, efficient, vector, databases, building, semantic, implementing, nearest, neighbor, queries, optimizing |
+| `spark-optimization` | Optimize Apache Spark jobs with partitioning, caching, shuffle optimization, and memory tuning. Use when improving Spark performance, debugging slow jobs, or... | spark, optimization | spark, optimization, optimize, apache, jobs, partitioning, caching, shuffle, memory, tuning, improving, performance |
+| `sql-optimization-patterns` | Master SQL query optimization, indexing strategies, and EXPLAIN analysis to dramatically improve database performance and eliminate slow queries. Use when de... | sql, optimization | sql, optimization, query, indexing, explain, analysis, dramatically, improve, database, performance, eliminate, slow |
+| `sqlmap-database-pentesting` | This skill should be used when the user asks to "automate SQL injection testing," "enumerate database structure," "extract database credentials using sqlmap,... | sqlmap, database, pentesting | sqlmap, database, pentesting, penetration, testing, skill, should, used, user, asks, automate, sql |
+| `tdd-orchestrator` | Master TDD orchestrator specializing in red-green-refactor discipline, multi-agent workflow coordination, and comprehensive test-driven development practices... | tdd, orchestrator | tdd, orchestrator, specializing, red, green, refactor, discipline, multi, agent, coordination, test, driven |
+| `team-collaboration-standup-notes` | You are an expert team communication specialist focused on async-first standup practices, AI-assisted note generation from commit history, and effective remo... | team, collaboration, standup, notes | team, collaboration, standup, notes, communication, async, first, ai, assisted, note, generation, commit |
+| `telegram-bot-builder` | Expert in building Telegram bots that solve real problems - from simple automation to complex AI-powered bots. Covers bot architecture, the Telegram Bot API,... | telegram, bot, builder | telegram, bot, builder, building, bots, solve, real, problems, simple, automation, complex, ai |
+| `trigger-dev` | Trigger.dev expert for background jobs, AI workflows, and reliable async execution with excellent developer experience and TypeScript-first design. Use when:... | trigger, dev | trigger, dev, background, jobs, ai, reliable, async, execution, excellent, developer, experience, typescript |
+| `unity-ecs-patterns` | Master Unity ECS (Entity Component System) with DOTS, Jobs, and Burst for high-performance game development. Use when building data-oriented games, optimizin... | unity, ecs | unity, ecs, entity, component, dots, jobs, burst, high, performance, game, development, building |
+| `vector-database-engineer` | Expert in vector databases, embedding strategies, and semantic search implementation. Masters Pinecone, Weaviate, Qdrant, Milvus, and pgvector for RAG applic... | vector, database | vector, database, engineer, databases, embedding, semantic, search, masters, pinecone, weaviate, qdrant, milvus |
+| `vector-index-tuning` | Optimize vector index performance for latency, recall, and memory. Use when tuning HNSW parameters, selecting quantization strategies, or scaling vector sear... | vector, index, tuning | vector, index, tuning, optimize, performance, latency, recall, memory, hnsw, parameters, selecting, quantization |
+| `voice-ai-development` | Expert in building voice AI applications - from real-time voice agents to voice-enabled apps. Covers OpenAI Realtime API, Vapi for voice agents, Deepgram for... | voice, ai | voice, ai, development, building, applications, real, time, agents, enabled, apps, covers, openai |
+| `voice-ai-engine-development` | Build real-time conversational AI voice engines using async worker pipelines, streaming transcription, LLM agents, and TTS synthesis with interrupt handling ... | voice, ai, engine | voice, ai, engine, development, real, time, conversational, engines, async, worker, pipelines, streaming |
+| `web-artifacts-builder` | Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use ... | web, artifacts, builder | web, artifacts, builder, suite, creating, elaborate, multi, component, claude, ai, html, frontend |
+| `xlsx` | Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work ... | xlsx | xlsx, spreadsheet, creation, editing, analysis, formulas, formatting, data, visualization, claude, work, spreadsheets |
+| `xlsx-official` | Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work ... | xlsx, official | xlsx, official, spreadsheet, creation, editing, analysis, formulas, formatting, data, visualization, claude, work |
+
+## development (72)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `3d-web-experience` | Expert in building 3D experiences for the web - Three.js, React Three Fiber, Spline, WebGL, and interactive 3D scenes. Covers product configurators, 3D portf... | 3d, web, experience | 3d, web, experience, building, experiences, three, js, react, fiber, spline, webgl, interactive |
+| `algolia-search` | Expert patterns for Algolia search implementation, indexing strategies, React InstantSearch, and relevance tuning Use when: adding search to, algolia, instan... | algolia, search | algolia, search, indexing, react, instantsearch, relevance, tuning, adding, api, functionality |
+| `api-design-principles` | Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, revie... | api, principles | api, principles, rest, graphql, intuitive, scalable, maintainable, apis, delight, developers, designing, new |
+| `api-documentation-generator` | Generate comprehensive, developer-friendly API documentation from code, including endpoints, parameters, examples, and best practices | api, documentation, generator | api, documentation, generator, generate, developer, friendly, code, including, endpoints, parameters, examples |
+| `api-patterns` | API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination. | api | api, principles, decision, making, rest, vs, graphql, trpc, selection, response, formats, versioning |
+| `app-store-optimization` | Complete App Store Optimization (ASO) toolkit for researching, optimizing, and tracking mobile app performance on Apple App Store and Google Play Store | app, store, optimization | app, store, optimization, complete, aso, toolkit, researching, optimizing, tracking, mobile, performance, apple |
+| `architecture-patterns` | Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex ... | architecture | architecture, proven, backend, including, clean, hexagonal, domain, driven, architecting, complex, refactoring, existing |
+| `async-python-patterns` | Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, ... | async, python | async, python, asyncio, concurrent, programming, await, high, performance, applications, building, apis, bound |
+| `azure-functions` | Expert patterns for Azure Functions development including isolated worker model, Durable Functions orchestration, cold start optimization, and production pat... | azure, functions | azure, functions, development, including, isolated, worker, model, durable, orchestration, cold, start, optimization |
+| `backend-dev-guidelines` | Opinionated backend development standards for Node.js + Express + TypeScript microservices. Covers layered architecture, BaseController pattern, dependency i... | backend, dev, guidelines | backend, dev, guidelines, opinionated, development, standards, node, js, express, typescript, microservices, covers |
+| `bullmq-specialist` | BullMQ expert for Redis-backed job queues, background processing, and reliable async execution in Node.js/TypeScript applications. Use when: bullmq, bull que... | bullmq | bullmq, redis, backed, job, queues, background, processing, reliable, async, execution, node, js |
+| `bun-development` | Modern JavaScript/TypeScript development with Bun runtime. Covers package management, bundling, testing, and migration from Node.js. Use when working with Bu... | bun | bun, development, javascript, typescript, runtime, covers, package, bundling, testing, migration, node, js |
+| `cc-skill-coding-standards` | Universal coding standards, best practices, and patterns for TypeScript, JavaScript, React, and Node.js development. | cc, skill, coding, standards | cc, skill, coding, standards, universal, typescript, javascript, react, node, js, development |
+| `cc-skill-frontend-patterns` | Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices. | cc, skill, frontend | cc, skill, frontend, development, react, next, js, state, performance, optimization, ui |
+| `context7-auto-research` | Automatically fetch latest library/framework documentation for Claude Code via Context7 API | context7, auto, research | context7, auto, research, automatically, fetch, latest, library, framework, documentation, claude, code, via |
+| `csharp-pro` | Write modern C# code with advanced features like records, pattern matching, and async/await. Optimizes .NET applications, implements enterprise patterns, and... | csharp | csharp, pro, write, code, features, like, records, matching, async, await, optimizes, net |
+| `discord-bot-architect` | Specialized skill for building production-ready Discord bots. Covers Discord.js (JavaScript) and Pycord (Python), gateway intents, slash commands, interactiv... | discord, bot | discord, bot, architect, specialized, skill, building, bots, covers, js, javascript, pycord, python |
+| `dotnet-architect` | Expert .NET backend architect specializing in C#, ASP.NET Core, Entity Framework, Dapper, and enterprise application patterns. Masters async/await, dependenc... | dotnet | dotnet, architect, net, backend, specializing, asp, core, entity, framework, dapper, enterprise, application |
+| `dotnet-backend-patterns` | Master C#/.NET backend development patterns for building robust APIs, MCP servers, and enterprise applications. Covers async/await, dependency injection, Ent... | dotnet, backend | dotnet, backend, net, development, building, robust, apis, mcp, servers, enterprise, applications, covers |
+| `exa-search` | Semantic search, similar content discovery, and structured research using Exa API | exa, search | exa, search, semantic, similar, content, discovery, structured, research, api |
+| `fastapi-pro` | Build high-performance async APIs with FastAPI, SQLAlchemy 2.0, and Pydantic V2. Master microservices, WebSockets, and modern Python async patterns. Use PROA... | fastapi | fastapi, pro, high, performance, async, apis, sqlalchemy, pydantic, v2, microservices, websockets, python |
+| `fastapi-templates` | Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applicati... | fastapi | fastapi, async, dependency, injection, error, handling, building, new, applications, setting, up, backend |
+| `firecrawl-scraper` | Deep web scraping, screenshots, PDF parsing, and website crawling using Firecrawl API | firecrawl, scraper | firecrawl, scraper, deep, web, scraping, screenshots, pdf, parsing, website, crawling, api |
+| `frontend-design` | Create distinctive, production-grade frontend interfaces with intentional aesthetics, high craft, and non-generic visual identity. Use when building or styli... | frontend | frontend, distinctive, grade, interfaces, intentional, aesthetics, high, craft, non, generic, visual, identity |
+| `frontend-developer` | Build React components, implement responsive layouts, and handle client-side state management. Masters React 19, Next.js 15, and modern frontend architecture... | frontend | frontend, developer, react, components, responsive, layouts, handle, client, side, state, masters, 19 |
+| `frontend-mobile-development-component-scaffold` | You are a React component architecture expert specializing in scaffolding production-ready, accessible, and performant components. Generate complete componen... | frontend, mobile, component | frontend, mobile, component, development, scaffold, react, architecture, specializing, scaffolding, accessible, performant, components |
+| `go-concurrency-patterns` | Master Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or de... | go, concurrency | go, concurrency, goroutines, channels, sync, primitives, context, building, concurrent, applications, implementing, worker |
+| `golang-pro` | Master Go 1.21+ with modern patterns, advanced concurrency, performance optimization, and production-ready microservices. Expert in the latest Go ecosystem i... | golang | golang, pro, go, 21, concurrency, performance, optimization, microservices, latest, ecosystem, including, generics |
+| `hubspot-integration` | Expert patterns for HubSpot CRM integration including OAuth authentication, CRM objects, associations, batch operations, webhooks, and custom objects. Covers... | hubspot, integration | hubspot, integration, crm, including, oauth, authentication, objects, associations, batch, operations, webhooks, custom |
+| `javascript-mastery` | Comprehensive JavaScript reference covering 33+ essential concepts every developer should know. From fundamentals like primitives and closures to advanced pa... | javascript, mastery | javascript, mastery, reference, covering, 33, essential, concepts, every, developer, should, know, fundamentals |
+| `javascript-pro` | Master modern JavaScript with ES6+, async patterns, and Node.js APIs. Handles promises, event loops, and browser/Node compatibility. Use PROACTIVELY for Java... | javascript | javascript, pro, es6, async, node, js, apis, promises, event, loops, browser, compatibility |
+| `javascript-testing-patterns` | Implement comprehensive testing strategies using Jest, Vitest, and Testing Library for unit tests, integration tests, and end-to-end testing with mocking, fi... | javascript | javascript, testing, jest, vitest, library, unit, tests, integration, mocking, fixtures, test, driven |
+| `javascript-typescript-typescript-scaffold` | You are a TypeScript project architecture expert specializing in scaffolding production-ready Node.js and frontend applications. Generate complete project st... | javascript, typescript | javascript, typescript, scaffold, architecture, specializing, scaffolding, node, js, frontend, applications, generate, complete |
+| `launch-strategy` | When the user wants to plan a product launch, feature announcement, or release strategy. Also use when the user mentions 'launch,' 'Product Hunt,' 'feature r... | launch | launch, user, wants, plan, product, feature, announcement, release, mentions, hunt, go, market |
+| `mcp-builder` | Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use whe... | mcp, builder | mcp, builder, creating, high, quality, model, context, protocol, servers, enable, llms, interact |
+| `memory-safety-patterns` | Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, ... | memory, safety | memory, safety, safe, programming, raii, ownership, smart, pointers, resource, rust, writing, code |
+| `mobile-design` | Mobile-first design and engineering doctrine for iOS and Android apps. Covers touch interaction, performance, platform conventions, offline behavior, and mob... | mobile | mobile, first, engineering, doctrine, ios, android, apps, covers, touch, interaction, performance, platform |
+| `mobile-developer` | Develop React Native, Flutter, or native mobile apps with modern architecture patterns. Masters cross-platform development, native integrations, offline sync... | mobile | mobile, developer, develop, react, native, flutter, apps, architecture, masters, cross, platform, development |
+| `modern-javascript-patterns` | Master ES6+ features including async/await, destructuring, spread operators, arrow functions, promises, modules, iterators, generators, and functional progra... | modern, javascript | modern, javascript, es6, features, including, async, await, destructuring, spread, operators, arrow, functions |
+| `multi-platform-apps-multi-platform` | Build and deploy the same feature consistently across web, mobile, and desktop platforms using API-first architecture and parallel implementation strategies. | multi, platform, apps | multi, platform, apps, deploy, same, feature, consistently, web, mobile, desktop, platforms, api |
+| `product-manager-toolkit` | Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market ... | product, manager | product, manager, toolkit, managers, including, rice, prioritization, customer, interview, analysis, prd, discovery |
+| `python-development-python-scaffold` | You are a Python project architecture expert specializing in scaffolding production-ready Python applications. Generate complete project structures with mode... | python | python, development, scaffold, architecture, specializing, scaffolding, applications, generate, complete, structures, tooling, uv |
+| `python-packaging` | Create distributable Python packages with proper project structure, setup.py/pyproject.toml, and publishing to PyPI. Use when packaging Python libraries, cre... | python, packaging | python, packaging, distributable, packages, proper, structure, setup, py, pyproject, toml, publishing, pypi |
+| `python-patterns` | Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying. | python | python, development, principles, decision, making, framework, selection, async, type, hints, structure, teaches |
+| `python-performance-optimization` | Profile and optimize Python code using cProfile, memory profilers, and performance best practices. Use when debugging slow Python code, optimizing bottleneck... | python, performance, optimization | python, performance, optimization, profile, optimize, code, cprofile, memory, profilers, debugging, slow, optimizing |
+| `python-pro` | Master Python 3.12+ with modern features, async programming, performance optimization, and production-ready practices. Expert in the latest Python ecosystem ... | python | python, pro, 12, features, async, programming, performance, optimization, latest, ecosystem, including, uv |
+| `python-testing-patterns` | Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites... | python | python, testing, pytest, fixtures, mocking, test, driven, development, writing, tests, setting, up |
+| `react-modernization` | Upgrade React applications to latest versions, migrate from class components to hooks, and adopt concurrent features. Use when modernizing React codebases, m... | react, modernization | react, modernization, upgrade, applications, latest, versions, migrate, class, components, hooks, adopt, concurrent |
+| `react-native-architecture` | Build production React Native apps with Expo, navigation, native modules, offline sync, and cross-platform patterns. Use when developing mobile apps, impleme... | react, native, architecture | react, native, architecture, apps, expo, navigation, modules, offline, sync, cross, platform, developing |
+| `react-patterns` | Modern React patterns and principles. Hooks, composition, performance, TypeScript best practices. | react | react, principles, hooks, composition, performance, typescript |
+| `react-state-management` | Master modern React state management with Redux Toolkit, Zustand, Jotai, and React Query. Use when setting up global state, managing server state, or choosin... | react, state | react, state, redux, toolkit, zustand, jotai, query, setting, up, global, managing, server |
+| `reference-builder` | Creates exhaustive technical references and API documentation. Generates comprehensive parameter listings, configuration guides, and searchable reference mat... | reference, builder | reference, builder, creates, exhaustive, technical, references, api, documentation, generates, parameter, listings, configuration |
+| `remotion-best-practices` | Best practices for Remotion - Video creation in React | remotion, video, react, animation, composition | remotion, video, react, animation, composition, creation |
+| `ruby-pro` | Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing fram... | ruby | ruby, pro, write, idiomatic, code, metaprogramming, rails, performance, optimization, specializes, gem, development |
+| `rust-async-patterns` | Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing conc... | rust, async | rust, async, programming, tokio, traits, error, handling, concurrent, building, applications, implementing, debugging |
+| `rust-pro` | Master Rust 1.75+ with modern async patterns, advanced type system features, and production-ready systems programming. Expert in the latest Rust ecosystem in... | rust | rust, pro, 75, async, type, features, programming, latest, ecosystem, including, tokio, axum |
+| `senior-fullstack` | Comprehensive fullstack development skill for building complete web applications with React, Next.js, Node.js, GraphQL, and PostgreSQL. Includes project scaf... | senior, fullstack | senior, fullstack, development, skill, building, complete, web, applications, react, next, js, node |
+| `shodan-reconnaissance` | This skill should be used when the user asks to "search for exposed devices on the internet," "perform Shodan reconnaissance," "find vulnerable services usin... | shodan, reconnaissance | shodan, reconnaissance, pentesting, skill, should, used, user, asks, search, exposed, devices, internet |
+| `shopify-apps` | Expert patterns for Shopify app development including Remix/React Router apps, embedded apps with App Bridge, webhook handling, GraphQL Admin API, Polaris co... | shopify, apps | shopify, apps, app, development, including, remix, react, router, embedded, bridge, webhook, handling |
+| `shopify-development` | Build Shopify apps, extensions, themes using GraphQL Admin API, Shopify CLI, Polaris UI, and Liquid.
+TRIGGER: "shopify", "shopify app", "checkout extension",... | shopify | shopify, development, apps, extensions, themes, graphql, admin, api, cli, polaris, ui, liquid |
+| `slack-bot-builder` | Build Slack apps using the Bolt framework across Python, JavaScript, and Java. Covers Block Kit for rich UIs, interactive components, slash commands, event h... | slack, bot, builder | slack, bot, builder, apps, bolt, framework, python, javascript, java, covers, block, kit |
+| `systems-programming-rust-project` | You are a Rust project architecture expert specializing in scaffolding production-ready Rust applications. Generate complete project structures with cargo to... | programming, rust | programming, rust, architecture, specializing, scaffolding, applications, generate, complete, structures, cargo, tooling, proper |
+| `tavily-web` | Web search, content extraction, crawling, and research capabilities using Tavily API | tavily, web | tavily, web, search, content, extraction, crawling, research, capabilities, api |
+| `telegram-mini-app` | Expert in building Telegram Mini Apps (TWA) - web apps that run inside Telegram with native-like experience. Covers the TON ecosystem, Telegram Web App API, ... | telegram, mini, app | telegram, mini, app, building, apps, twa, web, run, inside, native, like, experience |
+| `temporal-python-testing` | Test Temporal workflows with pytest, time-skipping, and mocking strategies. Covers unit testing, integration testing, replay testing, and local development s... | temporal, python | temporal, python, testing, test, pytest, time, skipping, mocking, covers, unit, integration, replay |
+| `typescript-advanced-types` | Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe app... | typescript, advanced, types | typescript, advanced, types, type, including, generics, conditional, mapped, literals, utility, building, safe |
+| `typescript-expert` | TypeScript and JavaScript expert with deep knowledge of type-level programming, performance optimization, monorepo management, migration strategies, and mode... | typescript | typescript, javascript, deep, knowledge, type, level, programming, performance, optimization, monorepo, migration, tooling |
+| `typescript-pro` | Master TypeScript with advanced types, generics, and strict type safety. Handles complex type systems, decorators, and enterprise-grade patterns. Use PROACTI... | typescript | typescript, pro, types, generics, strict, type, safety, complex, decorators, enterprise, grade, proactively |
+| `ui-ux-pro-max` | UI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 9 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwi... | ui, ux, max | ui, ux, max, pro, intelligence, 50, styles, 21, palettes, font, pairings, 20 |
+| `uv-package-manager` | Master the uv package manager for fast Python dependency management, virtual environments, and modern Python project workflows. Use when setting up Python pr... | uv, package, manager | uv, package, manager, fast, python, dependency, virtual, environments, setting, up, managing, dependencies |
+| `viral-generator-builder` | Expert in building shareable generator tools that go viral - name generators, quiz makers, avatar creators, personality tests, and calculator tools. Covers t... | viral, generator, builder | viral, generator, builder, building, shareable, go, name, generators, quiz, makers, avatar, creators |
+| `webapp-testing` | Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing... | webapp | webapp, testing, toolkit, interacting, local, web, applications, playwright, supports, verifying, frontend, functionality |
+
+## general (95)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `address-github-comments` | Use when you need to address review or issue comments on an open GitHub Pull Request using the gh CLI. | address, github, comments | address, github, comments, review, issue, open, pull, request, gh, cli |
+| `agent-manager-skill` | Manage multiple local CLI agents via tmux sessions (start/stop/monitor/assign) with cron-friendly scheduling. | agent, manager, skill | agent, manager, skill, multiple, local, cli, agents, via, tmux, sessions, start, stop |
+| `algorithmic-art` | Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, gener... | algorithmic, art | algorithmic, art, creating, p5, js, seeded, randomness, interactive, parameter, exploration, users, request |
+| `angular-migration` | Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applicat... | angular, migration | angular, migration, migrate, angularjs, hybrid, mode, incremental, component, rewriting, dependency, injection, updates |
+| `anti-reversing-techniques` | Understand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use when analyzing protected binaries, bypassing anti... | anti, reversing, techniques | anti, reversing, techniques, understand, obfuscation, protection, encountered, during, software, analysis, analyzing, protected |
+| `app-builder` | Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordina... | app, builder | app, builder, main, application, building, orchestrator, creates, full, stack, applications, natural, language |
+| `arm-cortex-expert` | Senior embedded software engineer specializing in firmware and driver development for ARM Cortex-M microcontrollers (Teensy, STM32, nRF52, SAMD). Decades of ... | arm, cortex | arm, cortex, senior, embedded, software, engineer, specializing, firmware, driver, development, microcontrollers, teensy |
+| `avalonia-layout-zafiro` | Guidelines for modern Avalonia UI layout using Zafiro.Avalonia, emphasizing shared styles, generic components, and avoiding XAML redundancy. | avalonia, layout, zafiro | avalonia, layout, zafiro, guidelines, ui, emphasizing, shared, styles, generic, components, avoiding, xaml |
+| `avalonia-zafiro-development` | Mandatory skills, conventions, and behavioral rules for Avalonia UI development using the Zafiro toolkit. | avalonia, zafiro | avalonia, zafiro, development, mandatory, skills, conventions, behavioral, rules, ui, toolkit |
+| `backtesting-frameworks` | Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developin... | backtesting, frameworks | backtesting, frameworks, robust, trading, proper, handling, look, ahead, bias, survivorship, transaction, costs |
+| `bazel-build-optimization` | Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise co... | bazel, build, optimization | bazel, build, optimization, optimize, large, scale, monorepos, configuring, implementing, remote, execution, optimizing |
+| `blockchain-developer` | Build production-ready Web3 applications, smart contracts, and decentralized systems. Implements DeFi protocols, NFT platforms, DAOs, and enterprise blockcha... | blockchain | blockchain, developer, web3, applications, smart, contracts, decentralized, implements, defi, protocols, nft, platforms |
+| `brand-guidelines-anthropic` | Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand co... | brand, guidelines, anthropic | brand, guidelines, anthropic, applies, official, colors, typography, any, sort, artifact, may, benefit |
+| `brand-guidelines-community` | Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand co... | brand, guidelines, community | brand, guidelines, community, applies, anthropic, official, colors, typography, any, sort, artifact, may |
+| `busybox-on-windows` | How to use a Win32 build of BusyBox to run many of the standard UNIX command line tools on Windows. | busybox, on, windows | busybox, on, windows, how, win32, run, many, standard, unix, command, line |
+| `c-pro` | Write efficient C code with proper memory management, pointer arithmetic, and system calls. Handles embedded systems, kernel modules, and performance-critica... | c | c, pro, write, efficient, code, proper, memory, pointer, arithmetic, calls, embedded, kernel |
+| `canvas-design` | Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art... | canvas | canvas, beautiful, visual, art, png, pdf, documents, philosophy, should, skill, user, asks |
+| `cc-skill-continuous-learning` | Development skill from everything-claude-code | cc, skill, continuous, learning | cc, skill, continuous, learning, development, everything, claude, code |
+| `cc-skill-project-guidelines-example` | Project Guidelines Skill (Example) | cc, skill, guidelines, example | cc, skill, guidelines, example |
+| `cc-skill-strategic-compact` | Development skill from everything-claude-code | cc, skill, strategic, compact | cc, skill, strategic, compact, development, everything, claude, code |
+| `claude-code-guide` | Master guide for using Claude Code effectively. Includes configuration templates, prompting strategies "Thinking" keywords, debugging techniques, and best pr... | claude, code | claude, code, effectively, includes, configuration, prompting, thinking, keywords, debugging, techniques, interacting, agent |
+| `clean-code` | Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments | clean, code | clean, code, pragmatic, coding, standards, concise, direct, no, engineering, unnecessary, comments |
+| `code-documentation-code-explain` | You are a code education expert specializing in explaining complex code through clear narratives, visual diagrams, and step-by-step breakdowns. Transform dif... | code, documentation, explain | code, documentation, explain, education, specializing, explaining, complex, through, clear, narratives, visual, diagrams |
+| `code-refactoring-context-restore` | Use when working with code refactoring context restore | code, refactoring, restore | code, refactoring, restore, context, working |
+| `code-refactoring-tech-debt` | You are a technical debt expert specializing in identifying, quantifying, and prioritizing technical debt in software projects. Analyze the codebase to uncov... | code, refactoring, tech, debt | code, refactoring, tech, debt, technical, specializing, identifying, quantifying, prioritizing, software, analyze, codebase |
+| `code-review-excellence` | Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use wh... | code, excellence | code, excellence, review, effective, provide, constructive, feedback, catch, bugs, early, foster, knowledge |
+| `codebase-cleanup-tech-debt` | You are a technical debt expert specializing in identifying, quantifying, and prioritizing technical debt in software projects. Analyze the codebase to uncov... | codebase, cleanup, tech, debt | codebase, cleanup, tech, debt, technical, specializing, identifying, quantifying, prioritizing, software, analyze, uncover |
+| `comprehensive-review-full-review` | Use when working with comprehensive review full review | comprehensive, full | comprehensive, full, review, working |
+| `comprehensive-review-pr-enhance` | You are a PR optimization expert specializing in creating high-quality pull requests that facilitate efficient code reviews. Generate comprehensive PR descri... | comprehensive, pr, enhance | comprehensive, pr, enhance, review, optimization, specializing, creating, high, quality, pull, requests, facilitate |
+| `concise-planning` | Use when a user asks for a plan for a coding task, to generate a clear, actionable, and atomic checklist. | concise, planning | concise, planning, user, asks, plan, coding, task, generate, clear, actionable, atomic, checklist |
+| `context-management-context-restore` | Use when working with context management context restore | restore | restore, context, working |
+| `context-management-context-save` | Use when working with context management context save | save | save, context, working |
+| `daily-news-report` | Scrapes content based on a preset URL list, filters high-quality technical information, and generates daily Markdown reports. | daily, news, report | daily, news, report, scrapes, content, preset, url, list, filters, high, quality, technical |
+| `debugging-strategies` | Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use ... | debugging, strategies | debugging, strategies, systematic, techniques, profiling, root, cause, analysis, efficiently, track, down, bugs |
+| `debugging-toolkit-smart-debug` | Use when working with debugging toolkit smart debug | debugging, debug | debugging, debug, toolkit, smart, working |
+| `dispatching-parallel-agents` | Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | dispatching, parallel, agents | dispatching, parallel, agents, facing, independent, tasks, worked, without, shared, state, sequential, dependencies |
+| `docx` | Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude ... | docx | docx, document, creation, editing, analysis, tracked, changes, comments, formatting, preservation, text, extraction |
+| `docx-official` | Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude ... | docx, official | docx, official, document, creation, editing, analysis, tracked, changes, comments, formatting, preservation, text |
+| `dx-optimizer` | Developer Experience specialist. Improves tooling, setup, and workflows. Use PROACTIVELY when setting up new projects, after team feedback, or when developme... | dx, optimizer | dx, optimizer, developer, experience, improves, tooling, setup, proactively, setting, up, new, after |
+| `environment-setup-guide` | Guide developers through setting up development environments with proper tools, dependencies, and configurations | environment, setup | environment, setup, developers, through, setting, up, development, environments, proper, dependencies, configurations |
+| `error-debugging-multi-agent-review` | Use when working with error debugging multi agent review | error, debugging, multi, agent | error, debugging, multi, agent, review, working |
+| `error-diagnostics-smart-debug` | Use when working with error diagnostics smart debug | error, diagnostics, debug | error, diagnostics, debug, smart, working |
+| `executing-plans` | Use when you have a written implementation plan to execute in a separate session with review checkpoints | executing, plans | executing, plans, written, plan, execute, separate, session, review, checkpoints |
+| `file-organizer` | Intelligently organizes files and folders by understanding context, finding duplicates, and suggesting better organizational structures. Use when user wants ... | file, organizer | file, organizer, intelligently, organizes, files, folders, understanding, context, finding, duplicates, suggesting, better |
+| `finishing-a-development-branch` | Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting s... | finishing, a, branch | finishing, a, branch, development, complete, all, tests, pass, decide, how, integrate, work |
+| `framework-migration-code-migrate` | You are a code migration expert specializing in transitioning codebases between frameworks, languages, versions, and platforms. Generate comprehensive migrat... | framework, migration, code, migrate | framework, migration, code, migrate, specializing, transitioning, codebases, between, frameworks, languages, versions, platforms |
+| `game-development` | Game development orchestrator. Routes to platform-specific skills based on project needs. | game | game, development, orchestrator, routes, platform, specific, skills |
+| `git-advanced-workflows` | Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use... | git, advanced | git, advanced, including, rebasing, cherry, picking, bisect, worktrees, reflog, maintain, clean, history |
+| `git-pr-workflows-onboard` | You are an **expert onboarding specialist and knowledge transfer architect** with deep experience in remote-first organizations, technical team integration, ... | git, pr, onboard | git, pr, onboard, onboarding, knowledge, transfer, architect, deep, experience, remote, first, organizations |
+| `git-pr-workflows-pr-enhance` | You are a PR optimization expert specializing in creating high-quality pull requests that facilitate efficient code reviews. Generate comprehensive PR descri... | git, pr, enhance | git, pr, enhance, optimization, specializing, creating, high, quality, pull, requests, facilitate, efficient |
+| `infinite-gratitude` | Multi-agent research skill for parallel research execution (10 agents, battle-tested with real case studies). | infinite, gratitude | infinite, gratitude, multi, agent, research, skill, parallel, execution, 10, agents, battle, tested |
+| `interactive-portfolio` | Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, d... | interactive, portfolio | interactive, portfolio, building, portfolios, actually, land, jobs, clients, just, showing, work, creating |
+| `last30days` | Research a topic from the last 30 days on Reddit + X + Web, become an expert, and write copy-paste-ready prompts for the user's target tool. | last30days | last30days, research, topic, last, 30, days, reddit, web, become, write, copy, paste |
+| `legacy-modernizer` | Refactor legacy codebases, migrate outdated frameworks, and implement gradual modernization. Handles technical debt, dependency updates, and backward compati... | legacy, modernizer | legacy, modernizer, refactor, codebases, migrate, outdated, frameworks, gradual, modernization, technical, debt, dependency |
+| `lint-and-validate` | Automatic quality control, linting, and static analysis procedures. Use after every code modification to ensure syntax correctness and project standards. Tri... | lint, and, validate | lint, and, validate, automatic, quality, control, linting, static, analysis, procedures, after, every |
+| `linux-privilege-escalation` | This skill should be used when the user asks to "escalate privileges on Linux", "find privesc vectors on Linux systems", "exploit sudo misconfigurations", "a... | linux, privilege, escalation | linux, privilege, escalation, skill, should, used, user, asks, escalate, privileges, find, privesc |
+| `linux-shell-scripting` | This skill should be used when the user asks to "create bash scripts", "automate Linux tasks", "monitor system resources", "backup files", "manage users", or... | linux, shell, scripting | linux, shell, scripting, scripts, skill, should, used, user, asks, bash, automate, tasks |
+| `micro-saas-launcher` | Expert in launching small, focused SaaS products fast - the indie hacker approach to building profitable software. Covers idea validation, MVP development, p... | micro, saas, launcher | micro, saas, launcher, launching, small, products, fast, indie, hacker, approach, building, profitable |
+| `monorepo-management` | Master monorepo management with Turborepo, Nx, and pnpm workspaces to build efficient, scalable multi-package repositories with optimized builds and dependen... | monorepo | monorepo, turborepo, nx, pnpm, workspaces, efficient, scalable, multi, package, repositories, optimized, dependency |
+| `nft-standards` | Implement NFT standards (ERC-721, ERC-1155) with proper metadata handling, minting strategies, and marketplace integration. Use when creating NFT contracts, ... | nft, standards | nft, standards, erc, 721, 1155, proper, metadata, handling, minting, marketplace, integration, creating |
+| `nosql-expert` | Expert guidance for distributed NoSQL databases (Cassandra, DynamoDB). Focuses on mental models, query-first modeling, single-table design, and avoiding hot ... | nosql | nosql, guidance, distributed, databases, cassandra, dynamodb, mental, models, query, first, modeling, single |
+| `obsidian-clipper-template-creator` | Guide for creating templates for the Obsidian Web Clipper. Use when you want to create a new clipping template, understand available variables, or format cli... | obsidian, clipper, creator | obsidian, clipper, creator, creating, web, want, new, clipping, understand, available, variables, format |
+| `onboarding-cro` | When the user wants to optimize post-signup onboarding, user activation, first-run experience, or time-to-value. Also use when the user mentions "onboarding ... | onboarding, cro | onboarding, cro, user, wants, optimize, post, signup, activation, first, run, experience, time |
+| `paid-ads` | When the user wants help with paid advertising campaigns on Google Ads, Meta (Facebook/Instagram), LinkedIn, Twitter/X, or other ad platforms. Also use when ... | paid, ads | paid, ads, user, wants, advertising, campaigns, google, meta, facebook, instagram, linkedin, twitter |
+| `paypal-integration` | Integrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processin... | paypal, integration | paypal, integration, integrate, payment, processing, express, checkout, subscriptions, refund, implementing, payments, online |
+| `performance-profiling` | Performance profiling principles. Measurement, analysis, and optimization techniques. | performance, profiling | performance, profiling, principles, measurement, analysis, optimization, techniques |
+| `personal-tool-builder` | Expert in building custom tools that solve your own problems first. The best products often start as personal tools - scratch your own itch, build for yourse... | personal, builder | personal, builder, building, custom, solve, own, problems, first, products, often, start, scratch |
+| `plan-writing` | Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work. | plan, writing | plan, writing, structured, task, planning, clear, breakdowns, dependencies, verification, criteria, implementing, features |
+| `planning-with-files` | Implements Manus-style file-based planning for complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when starting complex multi-step tasks,... | planning, with, files | planning, with, files, implements, manus, style, file, complex, tasks, creates, task, plan |
+| `posix-shell-pro` | Expert in strict POSIX sh scripting for maximum portability across Unix-like systems. Specializes in shell scripts that run on any POSIX-compliant shell (das... | posix, shell | posix, shell, pro, strict, sh, scripting, maximum, portability, unix, like, specializes, scripts |
+| `pptx` | Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying o... | pptx | pptx, presentation, creation, editing, analysis, claude, work, presentations, files, creating, new, modifying |
+| `pptx-official` | Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying o... | pptx, official | pptx, official, presentation, creation, editing, analysis, claude, work, presentations, files, creating, new |
+| `privilege-escalation-methods` | This skill should be used when the user asks to "escalate privileges", "get root access", "become administrator", "privesc techniques", "abuse sudo", "exploi... | privilege, escalation, methods | privilege, escalation, methods, skill, should, used, user, asks, escalate, privileges, get, root |
+| `prompt-library` | Curated collection of high-quality prompts for various use cases. Includes role-based prompts, task-specific templates, and prompt refinement techniques. Use... | prompt, library | prompt, library, curated, collection, high, quality, prompts, various, cases, includes, role, task |
+| `receiving-code-review` | Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technic... | receiving, code | receiving, code, review, feedback, before, implementing, suggestions, especially, seems, unclear, technically, questionable |
+| `referral-program` | When the user wants to create, optimize, or analyze a referral program, affiliate program, or word-of-mouth strategy. Also use when the user mentions 'referr... | referral, program | referral, program, user, wants, optimize, analyze, affiliate, word, mouth, mentions, ambassador, viral |
+| `requesting-code-review` | Use when completing tasks, implementing major features, or before merging to verify work meets requirements | requesting, code | requesting, code, review, completing, tasks, implementing, major, features, before, merging, verify, work |
+| `search-specialist` | Expert web researcher using advanced search techniques and synthesis. Masters search operators, result filtering, and multi-source verification. Handles comp... | search | search, web, researcher, techniques, synthesis, masters, operators, result, filtering, multi, source, verification |
+| `shellcheck-configuration` | Master ShellCheck static analysis configuration and usage for shell script quality. Use when setting up linting infrastructure, fixing code issues, or ensuri... | shellcheck, configuration | shellcheck, configuration, static, analysis, usage, shell, script, quality, setting, up, linting, infrastructure |
+| `signup-flow-cro` | When the user wants to optimize signup, registration, account creation, or trial activation flows. Also use when the user mentions "signup conversions," "reg... | signup, flow, cro | signup, flow, cro, user, wants, optimize, registration, account, creation, trial, activation, flows |
+| `skill-creator` | Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capa... | skill, creator | skill, creator, creating, effective, skills, should, used, users, want, new, update, existing |
+| `slack-gif-creator` | Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users reques... | slack, gif, creator | slack, gif, creator, knowledge, utilities, creating, animated, gifs, optimized, provides, constraints, validation |
+| `social-content` | When the user wants help creating, scheduling, or optimizing social media content for LinkedIn, Twitter/X, Instagram, TikTok, Facebook, or other platforms. A... | social, content | social, content, user, wants, creating, scheduling, optimizing, media, linkedin, twitter, instagram, tiktok |
+| `subagent-driven-development` | Use when executing implementation plans with independent tasks in the current session | subagent, driven | subagent, driven, development, executing, plans, independent, tasks, current, session |
+| `theme-factory` | Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors... | theme, factory | theme, factory, toolkit, styling, artifacts, these, slides, docs, reportings, html, landing, pages |
+| `turborepo-caching` | Configure Turborepo for efficient monorepo builds with local and remote caching. Use when setting up Turborepo, optimizing build pipelines, or implementing d... | turborepo, caching | turborepo, caching, configure, efficient, monorepo, local, remote, setting, up, optimizing, pipelines, implementing |
+| `tutorial-engineer` | Creates step-by-step tutorials and educational content from code. Transforms complex concepts into progressive learning experiences with hands-on examples. U... | tutorial | tutorial, engineer, creates, step, tutorials, educational, content, code, transforms, complex, concepts, progressive |
+| `ui-ux-designer` | Create interface designs, wireframes, and design systems. Masters user research, accessibility standards, and modern design tools. Specializes in design toke... | ui, ux, designer | ui, ux, designer, interface, designs, wireframes, masters, user, research, accessibility, standards, specializes |
+| `upstash-qstash` | Upstash QStash expert for serverless message queues, scheduled jobs, and reliable HTTP-based task delivery without managing infrastructure. Use when: qstash,... | upstash, qstash | upstash, qstash, serverless, message, queues, scheduled, jobs, reliable, http, task, delivery, without |
+| `using-git-worktrees` | Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with sma... | using, git, worktrees | using, git, worktrees, starting, feature, work, isolation, current, workspace, before, executing, plans |
+| `using-superpowers` | Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions | using, superpowers | using, superpowers, starting, any, conversation, establishes, how, find, skills, requiring, skill, invocation |
+| `verification-before-completion` | Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output... | verification, before, completion | verification, before, completion, about, claim, work, complete, fixed, passing, committing, creating, prs |
+| `web-performance-optimization` | Optimize website and web application performance including loading speed, Core Web Vitals, bundle size, caching strategies, and runtime performance | web, performance, optimization | web, performance, optimization, optimize, website, application, including, loading, speed, core, vitals, bundle |
+| `windows-privilege-escalation` | This skill should be used when the user asks to "escalate privileges on Windows," "find Windows privesc vectors," "enumerate Windows for privilege escalation... | windows, privilege, escalation | windows, privilege, escalation, skill, should, used, user, asks, escalate, privileges, find, privesc |
+| `writing-plans` | Use when you have a spec or requirements for a multi-step task, before touching code | writing, plans | writing, plans, spec, requirements, multi, step, task, before, touching, code |
+
+## infrastructure (72)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `agent-evaluation` | Testing and benchmarking LLM agents including behavioral testing, capability assessment, reliability metrics, and production monitoring—where even top agents... | agent, evaluation | agent, evaluation, testing, benchmarking, llm, agents, including, behavioral, capability, assessment, reliability, metrics |
+| `airflow-dag-patterns` | Build production Apache Airflow DAGs with best practices for operators, sensors, testing, and deployment. Use when creating data pipelines, orchestrating wor... | airflow, dag | airflow, dag, apache, dags, operators, sensors, testing, deployment, creating, data, pipelines, orchestrating |
+| `api-testing-observability-api-mock` | You are an API mocking expert specializing in realistic mock services for development, testing, and demos. Design mocks that simulate real API behavior and e... | api, observability, mock | api, observability, mock, testing, mocking, specializing, realistic, development, demos, mocks, simulate, real |
+| `application-performance-performance-optimization` | Optimize end-to-end application performance with profiling, observability, and backend/frontend tuning. Use when coordinating performance optimization across... | application, performance, optimization | application, performance, optimization, optimize, profiling, observability, backend, frontend, tuning, coordinating, stack |
+| `aws-serverless` | Specialized skill for building production-ready serverless applications on AWS. Covers Lambda functions, API Gateway, DynamoDB, SQS/SNS event-driven patterns... | aws, serverless | aws, serverless, specialized, skill, building, applications, covers, lambda, functions, api, gateway, dynamodb |
+| `backend-architect` | Expert backend architect specializing in scalable API design, microservices architecture, and distributed systems. Masters REST/GraphQL/gRPC APIs, event-driv... | backend | backend, architect, specializing, scalable, api, microservices, architecture, distributed, masters, rest, graphql, grpc |
+| `backend-development-feature-development` | Orchestrate end-to-end backend feature development from requirements to deployment. Use when coordinating multi-phase feature delivery across teams and servi... | backend | backend, development, feature, orchestrate, requirements, deployment, coordinating, multi, phase, delivery, teams |
+| `bash-defensive-patterns` | Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requir... | bash, defensive | bash, defensive, programming, techniques, grade, scripts, writing, robust, shell, ci, cd, pipelines |
+| `bash-pro` | Master of defensive Bash scripting for production automation, CI/CD pipelines, and system utilities. Expert in safe, portable, and testable shell scripts. | bash | bash, pro, defensive, scripting, automation, ci, cd, pipelines, utilities, safe, portable, testable |
+| `bats-testing-patterns` | Master Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring t... | bats | bats, testing, bash, automated, shell, script, writing, tests, scripts, ci, cd, pipelines |
+| `c4-container` | Expert C4 Container-level documentation specialist. Synthesizes Component-level documentation into Container-level architecture, mapping components to deploy... | c4, container | c4, container, level, documentation, synthesizes, component, architecture, mapping, components, deployment, units, documenting |
+| `claude-d3js-skill` | Creating interactive data visualisations using d3.js. This skill should be used when creating custom charts, graphs, network diagrams, geographic visualisati... | claude, d3js, skill | claude, d3js, skill, d3, viz, creating, interactive, data, visualisations, js, should, used |
+| `code-review-ai-ai-review` | You are an expert AI-powered code review specialist combining automated static analysis, intelligent pattern recognition, and modern DevOps practices. Levera... | code, ai | code, ai, review, powered, combining, automated, static, analysis, intelligent, recognition, devops, leverage |
+| `cost-optimization` | Optimize cloud costs through resource rightsizing, tagging strategies, reserved instances, and spending analysis. Use when reducing cloud expenses, analyzing... | cost, optimization | cost, optimization, optimize, cloud, costs, through, resource, rightsizing, tagging, reserved, instances, spending |
+| `data-engineer` | Build scalable data pipelines, modern data warehouses, and real-time streaming architectures. Implements Apache Spark, dbt, Airflow, and cloud-native data pl... | data | data, engineer, scalable, pipelines, warehouses, real, time, streaming, architectures, implements, apache, spark |
+| `data-engineering-data-pipeline` | You are a data pipeline architecture expert specializing in scalable, reliable, and cost-effective data pipelines for batch and streaming data processing. | data, engineering, pipeline | data, engineering, pipeline, architecture, specializing, scalable, reliable, cost, effective, pipelines, batch, streaming |
+| `database-cloud-optimization-cost-optimize` | You are a cloud cost optimization expert specializing in reducing infrastructure expenses while maintaining performance and reliability. Analyze cloud spendi... | database, cloud, optimization, cost, optimize | database, cloud, optimization, cost, optimize, specializing, reducing, infrastructure, expenses, while, maintaining, performance |
+| `database-migrations-migration-observability` | Migration monitoring, CDC, and observability infrastructure | database, cdc, debezium, kafka, prometheus, grafana, monitoring | database, cdc, debezium, kafka, prometheus, grafana, monitoring, migrations, migration, observability, infrastructure |
+| `database-optimizer` | Expert database optimizer specializing in modern performance tuning, query optimization, and scalable architectures. Masters advanced indexing, N+1 resolutio... | database, optimizer | database, optimizer, specializing, performance, tuning, query, optimization, scalable, architectures, masters, indexing, resolution |
+| `deployment-procedures` | Production deployment principles and decision-making. Safe deployment workflows, rollback strategies, and verification. Teaches thinking, not scripts. | deployment, procedures | deployment, procedures, principles, decision, making, safe, rollback, verification, teaches, thinking, scripts |
+| `deployment-validation-config-validate` | You are a configuration management expert specializing in validating, testing, and ensuring the correctness of application configurations. Create comprehensi... | deployment, validation, config, validate | deployment, validation, config, validate, configuration, specializing, validating, testing, ensuring, correctness, application, configurations |
+| `distributed-debugging-debug-trace` | You are a debugging expert specializing in setting up comprehensive debugging environments, distributed tracing, and diagnostic tools. Configure debugging wo... | distributed, debugging, debug, trace | distributed, debugging, debug, trace, specializing, setting, up, environments, tracing, diagnostic, configure, solutions |
+| `distributed-tracing` | Implement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging microserv... | distributed, tracing | distributed, tracing, jaeger, tempo, track, requests, microservices, identify, performance, bottlenecks, debugging, analyzing |
+| `django-pro` | Master Django 5.x with async views, DRF, Celery, and Django Channels. Build scalable web applications with proper architecture, testing, and deployment. Use ... | django | django, pro, async, views, drf, celery, channels, scalable, web, applications, proper, architecture |
+| `e2e-testing-patterns` | Master end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs, improve confidence, and enable fast deployment. Use when... | e2e | e2e, testing, playwright, cypress, reliable, test, suites, catch, bugs, improve, confidence, enable |
+| `error-debugging-error-analysis` | You are an expert error analysis specialist with deep expertise in debugging distributed systems, analyzing production incidents, and implementing comprehens... | error, debugging | error, debugging, analysis, deep, expertise, distributed, analyzing, incidents, implementing, observability, solutions |
+| `error-debugging-error-trace` | You are an error tracking and observability expert specializing in implementing comprehensive error monitoring solutions. Set up error tracking systems, conf... | error, debugging, trace | error, debugging, trace, tracking, observability, specializing, implementing, monitoring, solutions, set, up, configure |
+| `error-diagnostics-error-analysis` | You are an expert error analysis specialist with deep expertise in debugging distributed systems, analyzing production incidents, and implementing comprehens... | error, diagnostics | error, diagnostics, analysis, deep, expertise, debugging, distributed, analyzing, incidents, implementing, observability, solutions |
+| `error-diagnostics-error-trace` | You are an error tracking and observability expert specializing in implementing comprehensive error monitoring solutions. Set up error tracking systems, conf... | error, diagnostics, trace | error, diagnostics, trace, tracking, observability, specializing, implementing, monitoring, solutions, set, up, configure |
+| `file-uploads` | Expert at handling file uploads and cloud storage. Covers S3, Cloudflare R2, presigned URLs, multipart uploads, and image optimization. Knows how to handle l... | file, uploads | file, uploads, handling, cloud, storage, covers, s3, cloudflare, r2, presigned, urls, multipart |
+| `flutter-expert` | Master Flutter development with Dart 3, advanced widgets, and multi-platform deployment. Handles state management, animations, testing, and performance optim... | flutter | flutter, development, dart, widgets, multi, platform, deployment, state, animations, testing, performance, optimization |
+| `gcp-cloud-run` | Specialized skill for building production-ready serverless applications on GCP. Covers Cloud Run services (containerized), Cloud Run Functions (event-driven)... | gcp, cloud, run | gcp, cloud, run, specialized, skill, building, serverless, applications, covers, containerized, functions, event |
+| `git-pr-workflows-git-workflow` | Orchestrate a comprehensive git workflow from code review through PR creation, leveraging specialized agents for quality assurance, testing, and deployment r... | git, pr | git, pr, orchestrate, code, review, through, creation, leveraging, specialized, agents, quality, assurance |
+| `github-actions-templates` | Create production-ready GitHub Actions workflows for automated testing, building, and deploying applications. Use when setting up CI/CD with GitHub Actions, ... | github, actions | github, actions, automated, testing, building, deploying, applications, setting, up, ci, cd, automating |
+| `github-workflow-automation` | Automate GitHub workflows with AI assistance. Includes PR reviews, issue triage, CI/CD integration, and Git operations. Use when automating GitHub workflows,... | github | github, automation, automate, ai, assistance, includes, pr, reviews, issue, triage, ci, cd |
+| `gitlab-ci-patterns` | Build GitLab CI/CD pipelines with multi-stage workflows, caching, and distributed runners for scalable automation. Use when implementing GitLab CI/CD, optimi... | gitlab, ci | gitlab, ci, cd, pipelines, multi, stage, caching, distributed, runners, scalable, automation, implementing |
+| `gitops-workflow` | Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOp... | gitops | gitops, argocd, flux, automated, declarative, kubernetes, deployments, continuous, reconciliation, implementing, automating, setting |
+| `grafana-dashboards` | Create and manage production Grafana dashboards for real-time visualization of system and application metrics. Use when building monitoring dashboards, visua... | grafana, dashboards | grafana, dashboards, real, time, visualization, application, metrics, building, monitoring, visualizing, creating, operational |
+| `helm-chart-scaffolding` | Design, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, pa... | helm, chart | helm, chart, scaffolding, organize, charts, templating, packaging, kubernetes, applications, reusable, configurations, creating |
+| `hybrid-cloud-networking` | Configure secure, high-performance connectivity between on-premises infrastructure and cloud platforms using VPN and dedicated connections. Use when building... | hybrid, cloud, networking | hybrid, cloud, networking, configure, secure, high, performance, connectivity, between, premises, infrastructure, platforms |
+| `istio-traffic-management` | Configure Istio traffic management including routing, load balancing, circuit breakers, and canary deployments. Use when implementing service mesh traffic po... | istio, traffic | istio, traffic, configure, including, routing, load, balancing, circuit, breakers, canary, deployments, implementing |
+| `java-pro` | Master Java 21+ with modern features like virtual threads, pattern matching, and Spring Boot 3.x. Expert in the latest Java ecosystem including GraalVM, Proj... | java | java, pro, 21, features, like, virtual, threads, matching, spring, boot, latest, ecosystem |
+| `kpi-dashboard-design` | Design effective KPI dashboards with metrics selection, visualization best practices, and real-time monitoring patterns. Use when building business dashboard... | kpi, dashboard | kpi, dashboard, effective, dashboards, metrics, selection, visualization, real, time, monitoring, building, business |
+| `langfuse` | Expert in Langfuse - the open-source LLM observability platform. Covers tracing, prompt management, evaluation, datasets, and integration with LangChain, Lla... | langfuse | langfuse, open, source, llm, observability, platform, covers, tracing, prompt, evaluation, datasets, integration |
+| `llm-app-patterns` | Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI... | llm, app | llm, app, building, applications, covers, rag, pipelines, agent, architectures, prompt, ides, llmops |
+| `machine-learning-ops-ml-pipeline` | Design and implement a complete ML pipeline for: $ARGUMENTS | machine, learning, ops, ml, pipeline | machine, learning, ops, ml, pipeline, complete, arguments |
+| `microservices-patterns` | Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decom... | microservices | microservices, architectures, boundaries, event, driven, communication, resilience, building, distributed, decomposing, monoliths, implementing |
+| `ml-engineer` | Build production ML systems with PyTorch 2.x, TensorFlow, and modern ML frameworks. Implements model serving, feature engineering, A/B testing, and monitorin... | ml | ml, engineer, pytorch, tensorflow, frameworks, implements, model, serving, feature, engineering, testing, monitoring |
+| `ml-pipeline-workflow` | Build end-to-end MLOps pipelines from data preparation through model training, validation, and production deployment. Use when creating ML pipelines, impleme... | ml, pipeline | ml, pipeline, mlops, pipelines, data, preparation, through, model, training, validation, deployment, creating |
+| `mlops-engineer` | Build comprehensive ML pipelines, experiment tracking, and model registries with MLflow, Kubeflow, and modern MLOps tools. Implements automated training, dep... | mlops | mlops, engineer, ml, pipelines, experiment, tracking, model, registries, mlflow, kubeflow, implements, automated |
+| `moodle-external-api-development` | Create custom external web service APIs for Moodle LMS. Use when implementing web services for course management, user tracking, quiz operations, or custom p... | moodle, external, api | moodle, external, api, development, custom, web, apis, lms, implementing, course, user, tracking |
+| `multi-cloud-architecture` | Design multi-cloud architectures using a decision framework to select and integrate services across AWS, Azure, and GCP. Use when building multi-cloud system... | multi, cloud, architecture | multi, cloud, architecture, architectures, decision, framework, select, integrate, aws, azure, gcp, building |
+| `network-101` | This skill should be used when the user asks to "set up a web server", "configure HTTP or HTTPS", "perform SNMP enumeration", "configure SMB shares", "test n... | network, 101 | network, 101, skill, should, used, user, asks, set, up, web, server, configure |
+| `observability-monitoring-monitor-setup` | You are a monitoring and observability expert specializing in implementing comprehensive monitoring solutions. Set up metrics collection, distributed tracing... | observability, monitoring, monitor, setup | observability, monitoring, monitor, setup, specializing, implementing, solutions, set, up, metrics, collection, distributed |
+| `observability-monitoring-slo-implement` | You are an SLO (Service Level Objective) expert specializing in implementing reliability standards and error budget-based practices. Design SLO frameworks, d... | observability, monitoring, slo, implement | observability, monitoring, slo, implement, level, objective, specializing, implementing, reliability, standards, error, budget |
+| `performance-engineer` | Expert performance engineer specializing in modern observability, application optimization, and scalable system performance. Masters OpenTelemetry, distribut... | performance | performance, engineer, specializing, observability, application, optimization, scalable, masters, opentelemetry, distributed, tracing, load |
+| `performance-testing-review-ai-review` | You are an expert AI-powered code review specialist combining automated static analysis, intelligent pattern recognition, and modern DevOps practices. Levera... | performance, ai | performance, ai, testing, review, powered, code, combining, automated, static, analysis, intelligent, recognition |
+| `prometheus-configuration` | Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, ... | prometheus, configuration | prometheus, configuration, set, up, metric, collection, storage, monitoring, infrastructure, applications, implementing, metrics |
+| `protocol-reverse-engineering` | Master network protocol reverse engineering including packet analysis, protocol dissection, and custom protocol documentation. Use when analyzing network tra... | protocol, reverse, engineering | protocol, reverse, engineering, network, including, packet, analysis, dissection, custom, documentation, analyzing, traffic |
+| `server-management` | Server management principles and decision-making. Process management, monitoring strategy, and scaling decisions. Teaches thinking, not commands. | server | server, principles, decision, making, process, monitoring, scaling, decisions, teaches, thinking, commands |
+| `service-mesh-observability` | Implement comprehensive observability for service meshes including distributed tracing, metrics, and visualization. Use when setting up mesh monitoring, debu... | service, mesh, observability | service, mesh, observability, meshes, including, distributed, tracing, metrics, visualization, setting, up, monitoring |
+| `slo-implementation` | Define and implement Service Level Indicators (SLIs) and Service Level Objectives (SLOs) with error budgets and alerting. Use when establishing reliability t... | slo | slo, define, level, indicators, slis, objectives, slos, error, budgets, alerting, establishing, reliability |
+| `sql-pro` | Master modern SQL with cloud-native databases, OLTP/OLAP optimization, and advanced query techniques. Expert in performance tuning, data modeling, and hybrid... | sql | sql, pro, cloud, native, databases, oltp, olap, optimization, query, techniques, performance, tuning |
+| `temporal-python-pro` | Master Temporal workflow orchestration with Python SDK. Implements durable workflows, saga patterns, and distributed transactions. Covers async/await, testin... | temporal, python | temporal, python, pro, orchestration, sdk, implements, durable, saga, distributed, transactions, covers, async |
+| `terraform-module-library` | Build reusable Terraform modules for AWS, Azure, and GCP infrastructure following infrastructure-as-code best practices. Use when creating infrastructure mod... | terraform, module, library | terraform, module, library, reusable, modules, aws, azure, gcp, infrastructure, following, code, creating |
+| `test-automator` | Master AI-powered test automation with modern frameworks, self-healing tests, and comprehensive quality engineering. Build scalable testing strategies with a... | automator | automator, test, ai, powered, automation, frameworks, self, healing, tests, quality, engineering, scalable |
+| `unity-developer` | Build Unity games with optimized C# scripts, efficient rendering, and proper asset management. Masters Unity 6 LTS, URP/HDRP pipelines, and cross-platform de... | unity | unity, developer, games, optimized, scripts, efficient, rendering, proper, asset, masters, lts, urp |
+| `vercel-deployment` | Expert knowledge for deploying to Vercel with Next.js Use when: vercel, deploy, deployment, hosting, production. | vercel, deployment | vercel, deployment, knowledge, deploying, next, js, deploy, hosting |
+| `voice-agents` | Voice agents represent the frontier of AI interaction - humans speaking naturally with AI systems. The challenge isn't just speech recognition and synthesis,... | voice, agents | voice, agents, represent, frontier, ai, interaction, humans, speaking, naturally, challenge, isn, just |
+| `wireshark-analysis` | This skill should be used when the user asks to "analyze network traffic with Wireshark", "capture packets for troubleshooting", "filter PCAP files", "follow... | wireshark | wireshark, network, traffic, analysis, skill, should, used, user, asks, analyze, capture, packets |
+| `workflow-automation` | Workflow automation is the infrastructure that makes AI agents reliable. Without durable execution, a network hiccup during a 10-step payment flow means lost... |  | automation, infrastructure, makes, ai, agents, reliable, without, durable, execution, network, hiccup, during |
+| `writing-skills` | Use when creating new skills, editing existing skills, or verifying skills work before deployment | writing, skills | writing, skills, creating, new, editing, existing, verifying, work, before, deployment |
+
+## security (107)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `accessibility-compliance-accessibility-audit` | You are an accessibility expert specializing in WCAG compliance, inclusive design, and assistive technology compatibility. Conduct audits, identify barriers,... | accessibility, compliance, audit | accessibility, compliance, audit, specializing, wcag, inclusive, assistive, technology, compatibility, conduct, audits, identify |
+| `active-directory-attacks` | This skill should be used when the user asks to "attack Active Directory", "exploit AD", "Kerberoasting", "DCSync", "pass-the-hash", "BloodHound enumeration"... | active, directory, attacks | active, directory, attacks, skill, should, used, user, asks, attack, exploit, ad, kerberoasting |
+| `agent-memory-systems` | Memory is the cornerstone of intelligent agents. Without it, every interaction starts from zero. This skill covers the architecture of agent memory: short-te... | agent, memory | agent, memory, cornerstone, intelligent, agents, without, every, interaction, starts, zero, skill, covers |
+| `ai-product` | Every product will be AI-powered. The question is whether you'll build it right or ship a demo that falls apart in production.  This skill covers LLM integra... | ai, product | ai, product, every, powered, question, whether, ll, right, ship, demo, falls, apart |
+| `api-fuzzing-bug-bounty` | This skill should be used when the user asks to "test API security", "fuzz APIs", "find IDOR vulnerabilities", "test REST API", "test GraphQL", "API penetrat... | api, fuzzing, bug, bounty | api, fuzzing, bug, bounty, skill, should, used, user, asks, test, security, fuzz |
+| `api-security-best-practices` | Implement secure API design patterns including authentication, authorization, input validation, rate limiting, and protection against common API vulnerabilities | api, security, best, practices | api, security, best, practices, secure, including, authentication, authorization, input, validation, rate, limiting |
+| `attack-tree-construction` | Build comprehensive attack trees to visualize threat paths. Use when mapping attack scenarios, identifying defense gaps, or communicating security risks to s... | attack, tree, construction | attack, tree, construction, trees, visualize, threat, paths, mapping, scenarios, identifying, defense, gaps |
+| `auth-implementation-patterns` | Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use wh... | auth | auth, authentication, authorization, including, jwt, oauth2, session, rbac, secure, scalable, access, control |
+| `aws-penetration-testing` | This skill should be used when the user asks to "pentest AWS", "test AWS security", "enumerate IAM", "exploit cloud infrastructure", "AWS privilege escalatio... | aws, penetration | aws, penetration, testing, skill, should, used, user, asks, pentest, test, security, enumerate |
+| `backend-security-coder` | Expert in secure backend coding practices specializing in input validation, authentication, and API security. Use PROACTIVELY for backend security implementa... | backend, security, coder | backend, security, coder, secure, coding, specializing, input, validation, authentication, api, proactively, implementations |
+| `broken-authentication` | This skill should be used when the user asks to "test for broken authentication vulnerabilities", "assess session management security", "perform credential s... | broken, authentication | broken, authentication, testing, skill, should, used, user, asks, test, vulnerabilities, assess, session |
+| `burp-suite-testing` | This skill should be used when the user asks to "intercept HTTP traffic", "modify web requests", "use Burp Suite for testing", "perform web vulnerability sca... | burp, suite | burp, suite, web, application, testing, skill, should, used, user, asks, intercept, http |
+| `cc-skill-security-review` | Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Pro... | cc, skill, security | cc, skill, security, review, adding, authentication, handling, user, input, working, secrets, creating |
+| `cicd-automation-workflow-automate` | You are a workflow automation expert specializing in creating efficient CI/CD pipelines, GitHub Actions workflows, and automated development processes. Desig... | cicd, automate | cicd, automate, automation, specializing, creating, efficient, ci, cd, pipelines, github, actions, automated |
+| `clerk-auth` | Expert patterns for Clerk auth implementation, middleware, organizations, webhooks, and user sync Use when: adding authentication, clerk auth, user authentic... | clerk, auth | clerk, auth, middleware, organizations, webhooks, user, sync, adding, authentication, sign, up |
+| `cloud-architect` | Expert cloud architect specializing in AWS/Azure/GCP multi-cloud infrastructure design, advanced IaC (Terraform/OpenTofu/CDK), FinOps cost optimization, and ... | cloud | cloud, architect, specializing, aws, azure, gcp, multi, infrastructure, iac, terraform, opentofu, cdk |
+| `cloud-penetration-testing` | This skill should be used when the user asks to "perform cloud penetration testing", "assess Azure or AWS or GCP security", "enumerate cloud resources", "exp... | cloud, penetration | cloud, penetration, testing, skill, should, used, user, asks, perform, assess, azure, aws |
+| `code-review-checklist` | Comprehensive checklist for conducting thorough code reviews covering functionality, security, performance, and maintainability | code, checklist | code, checklist, review, conducting, thorough, reviews, covering, functionality, security, performance, maintainability |
+| `code-reviewer` | Elite code review expert specializing in modern AI-powered code analysis, security vulnerabilities, performance optimization, and production reliability. Mas... | code | code, reviewer, elite, review, specializing, ai, powered, analysis, security, vulnerabilities, performance, optimization |
+| `codebase-cleanup-deps-audit` | You are a dependency security expert specializing in vulnerability scanning, license compliance, and supply chain security. Analyze project dependencies for ... | codebase, cleanup, deps, audit | codebase, cleanup, deps, audit, dependency, security, specializing, vulnerability, scanning, license, compliance, supply |
+| `computer-use-agents` | Build AI agents that interact with computers like humans do - viewing screens, moving cursors, clicking buttons, and typing text. Covers Anthropic's Computer... | computer, use, agents | computer, use, agents, ai, interact, computers, like, humans, do, viewing, screens, moving |
+| `database-admin` | Expert database administrator specializing in modern cloud databases, automation, and reliability engineering. Masters AWS/Azure/GCP database services, Infra... | database, admin | database, admin, administrator, specializing, cloud, databases, automation, reliability, engineering, masters, aws, azure |
+| `database-migration` | Execute database migrations across ORMs and platforms with zero-downtime strategies, data transformation, and rollback procedures. Use when migrating databas... | database, migration | database, migration, execute, migrations, orms, platforms, zero, downtime, data, transformation, rollback, procedures |
+| `database-migrations-sql-migrations` | SQL database migrations with zero-downtime strategies for PostgreSQL, MySQL, SQL Server | database, sql, migrations, postgresql, mysql, flyway, liquibase, alembic, zero-downtime | database, sql, migrations, postgresql, mysql, flyway, liquibase, alembic, zero-downtime, zero, downtime, server |
+| `dependency-management-deps-audit` | You are a dependency security expert specializing in vulnerability scanning, license compliance, and supply chain security. Analyze project dependencies for ... | dependency, deps, audit | dependency, deps, audit, security, specializing, vulnerability, scanning, license, compliance, supply, chain, analyze |
+| `deployment-engineer` | Expert deployment engineer specializing in modern CI/CD pipelines, GitOps workflows, and advanced deployment automation. Masters GitHub Actions, ArgoCD/Flux,... | deployment | deployment, engineer, specializing, ci, cd, pipelines, gitops, automation, masters, github, actions, argocd |
+| `deployment-pipeline-design` | Design multi-stage CI/CD pipelines with approval gates, security checks, and deployment orchestration. Use when architecting deployment workflows, setting up... | deployment, pipeline | deployment, pipeline, multi, stage, ci, cd, pipelines, approval, gates, security, checks, orchestration |
+| `design-orchestration` | Orchestrates design workflows by routing work through brainstorming, multi-agent review, and execution readiness in the correct order. Prevents premature imp... |  | orchestration, orchestrates, routing, work, through, brainstorming, multi, agent, review, execution, readiness, correct |
+| `devops-troubleshooter` | Expert DevOps troubleshooter specializing in rapid incident response, advanced debugging, and modern observability. Masters log analysis, distributed tracing... | devops, troubleshooter | devops, troubleshooter, specializing, rapid, incident, response, debugging, observability, masters, log, analysis, distributed |
+| `docker-expert` | Docker containerization expert with deep knowledge of multi-stage builds, image optimization, container security, Docker Compose orchestration, and productio... | docker | docker, containerization, deep, knowledge, multi, stage, image, optimization, container, security, compose, orchestration |
+| `ethical-hacking-methodology` | This skill should be used when the user asks to "learn ethical hacking", "understand penetration testing lifecycle", "perform reconnaissance", "conduct secur... | ethical, hacking, methodology | ethical, hacking, methodology, skill, should, used, user, asks, learn, understand, penetration, testing |
+| `file-path-traversal` | This skill should be used when the user asks to "test for directory traversal", "exploit path traversal vulnerabilities", "read arbitrary files through web a... | file, path, traversal | file, path, traversal, testing, skill, should, used, user, asks, test, directory, exploit |
+| `firebase` | Firebase gives you a complete backend in minutes - auth, database, storage, functions, hosting. But the ease of setup hides real complexity. Security rules a... | firebase | firebase, gives, complete, backend, minutes, auth, database, storage, functions, hosting, ease, setup |
+| `firmware-analyst` | Expert firmware analyst specializing in embedded systems, IoT security, and hardware reverse engineering. Masters firmware extraction, analysis, and vulnerab... | firmware, analyst | firmware, analyst, specializing, embedded, iot, security, hardware, reverse, engineering, masters, extraction, analysis |
+| `form-cro` | Optimize any form that is NOT signup or account registration — including lead capture, contact, demo request, application, survey, quote, and checkout forms.... | form, cro | form, cro, optimize, any, signup, account, registration, including, lead, capture, contact, demo |
+| `framework-migration-deps-upgrade` | You are a dependency management expert specializing in safe, incremental upgrades of project dependencies. Plan and execute dependency updates with minimal r... | framework, migration, deps, upgrade | framework, migration, deps, upgrade, dependency, specializing, safe, incremental, upgrades, dependencies, plan, execute |
+| `frontend-mobile-security-xss-scan` | You are a frontend security specialist focusing on Cross-Site Scripting (XSS) vulnerability detection and prevention. Analyze React, Vue, Angular, and vanill... | frontend, mobile, security, xss, scan | frontend, mobile, security, xss, scan, focusing, cross, site, scripting, vulnerability, detection, prevention |
+| `frontend-security-coder` | Expert in secure frontend coding practices specializing in XSS prevention, output sanitization, and client-side security patterns. Use PROACTIVELY for fronte... | frontend, security, coder | frontend, security, coder, secure, coding, specializing, xss, prevention, output, sanitization, client, side |
+| `gdpr-data-handling` | Implement GDPR-compliant data handling with consent management, data subject rights, and privacy by design. Use when building systems that process EU persona... | gdpr, data, handling | gdpr, data, handling, compliant, consent, subject, rights, privacy, building, process, eu, personal |
+| `graphql-architect` | Master modern GraphQL with federation, performance optimization, and enterprise security. Build scalable schemas, implement advanced caching, and design real... | graphql | graphql, architect, federation, performance, optimization, enterprise, security, scalable, schemas, caching, real, time |
+| `html-injection-testing` | This skill should be used when the user asks to "test for HTML injection", "inject HTML into web pages", "perform HTML injection attacks", "deface web applic... | html, injection | html, injection, testing, skill, should, used, user, asks, test, inject, web, pages |
+| `hybrid-cloud-architect` | Expert hybrid cloud architect specializing in complex multi-cloud solutions across AWS/Azure/GCP and private clouds (OpenStack/VMware). Masters hybrid connec... | hybrid, cloud | hybrid, cloud, architect, specializing, complex, multi, solutions, aws, azure, gcp, private, clouds |
+| `idor-testing` | This skill should be used when the user asks to "test for insecure direct object references," "find IDOR vulnerabilities," "exploit broken access control," "... | idor | idor, vulnerability, testing, skill, should, used, user, asks, test, insecure, direct, object |
+| `incident-responder` | Expert SRE incident responder specializing in rapid problem resolution, modern observability, and comprehensive incident management. Masters incident command... | incident, responder | incident, responder, sre, specializing, rapid, problem, resolution, observability, masters, command, blameless, post |
+| `incident-response-incident-response` | Use when working with incident response incident response | incident, response | incident, response, working |
+| `incident-response-smart-fix` | [Extended thinking: This workflow implements a sophisticated debugging and resolution pipeline that leverages AI-assisted debugging tools and observability p... | incident, response, fix | incident, response, fix, smart, extended, thinking, implements, sophisticated, debugging, resolution, pipeline, leverages |
+| `incident-runbook-templates` | Create structured incident response runbooks with step-by-step procedures, escalation paths, and recovery actions. Use when building runbooks, responding to ... | incident, runbook | incident, runbook, structured, response, runbooks, step, procedures, escalation, paths, recovery, actions, building |
+| `internal-comms-anthropic` | A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenev... | internal, comms, anthropic | internal, comms, anthropic, set, resources, me, write, all, kinds, communications, formats, my |
+| `internal-comms-community` | A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenev... | internal, comms, community | internal, comms, community, set, resources, me, write, all, kinds, communications, formats, my |
+| `k8s-manifest-generator` | Create production-ready Kubernetes manifests for Deployments, Services, ConfigMaps, and Secrets following best practices and security standards. Use when gen... | k8s, manifest, generator | k8s, manifest, generator, kubernetes, manifests, deployments, configmaps, secrets, following, security, standards, generating |
+| `k8s-security-policies` | Implement Kubernetes security policies including NetworkPolicy, PodSecurityPolicy, and RBAC for production-grade security. Use when securing Kubernetes clust... | k8s, security, policies | k8s, security, policies, kubernetes, including, networkpolicy, podsecuritypolicy, rbac, grade, securing, clusters, implementing |
+| `kubernetes-architect` | Expert Kubernetes architect specializing in cloud-native infrastructure, advanced GitOps workflows (ArgoCD/Flux), and enterprise container orchestration. Mas... | kubernetes | kubernetes, architect, specializing, cloud, native, infrastructure, gitops, argocd, flux, enterprise, container, orchestration |
+| `legal-advisor` | Draft privacy policies, terms of service, disclaimers, and legal notices. Creates GDPR-compliant texts, cookie policies, and data processing agreements. Use ... | legal, advisor | legal, advisor, draft, privacy, policies, terms, disclaimers, notices, creates, gdpr, compliant, texts |
+| `linkerd-patterns` | Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies... | linkerd | linkerd, mesh, lightweight, security, deployments, setting, up, configuring, traffic, policies, implementing, zero |
+| `loki-mode` | Multi-agent autonomous startup system for Claude Code. Triggers on "Loki Mode". Orchestrates 100+ specialized agents across engineering, QA, DevOps, security... | loki, mode | loki, mode, multi, agent, autonomous, startup, claude, code, triggers, orchestrates, 100, specialized |
+| `malware-analyst` | Expert malware analyst specializing in defensive malware research, threat intelligence, and incident response. Masters sandbox analysis, behavioral analysis,... | malware, analyst | malware, analyst, specializing, defensive, research, threat, intelligence, incident, response, masters, sandbox, analysis |
+| `memory-forensics` | Master memory forensics techniques including memory acquisition, process analysis, and artifact extraction using Volatility and related tools. Use when analy... | memory, forensics | memory, forensics, techniques, including, acquisition, process, analysis, artifact, extraction, volatility, related, analyzing |
+| `metasploit-framework` | This skill should be used when the user asks to "use Metasploit for penetration testing", "exploit vulnerabilities with msfconsole", "create payloads with ms... | metasploit, framework | metasploit, framework, skill, should, used, user, asks, penetration, testing, exploit, vulnerabilities, msfconsole |
+| `mobile-security-coder` | Expert in secure mobile coding practices specializing in input validation, WebView security, and mobile-specific security patterns. Use PROACTIVELY for mobil... | mobile, security, coder | mobile, security, coder, secure, coding, specializing, input, validation, webview, specific, proactively, implementations |
+| `mtls-configuration` | Configure mutual TLS (mTLS) for zero-trust service-to-service communication. Use when implementing zero-trust networking, certificate management, or securing... | mtls, configuration | mtls, configuration, configure, mutual, tls, zero, trust, communication, implementing, networking, certificate, securing |
+| `multi-agent-brainstorming` | Use this skill when a design or idea requires higher confidence, risk reduction, or formal review. This skill orchestrates a structured, sequential multi-age... | multi, agent, brainstorming | multi, agent, brainstorming, skill, idea, requires, higher, confidence, risk, reduction, formal, review |
+| `network-engineer` | Expert network engineer specializing in modern cloud networking, security architectures, and performance optimization. Masters multi-cloud connectivity, serv... | network | network, engineer, specializing, cloud, networking, security, architectures, performance, optimization, masters, multi, connectivity |
+| `nextjs-supabase-auth` | Expert integration of Supabase Auth with Next.js App Router Use when: supabase auth next, authentication next.js, login supabase, auth middleware, protected ... | nextjs, supabase, auth | nextjs, supabase, auth, integration, next, js, app, router, authentication, login, middleware, protected |
+| `nodejs-best-practices` | Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying. | nodejs, best, practices | nodejs, best, practices, node, js, development, principles, decision, making, framework, selection, async |
+| `notebooklm` | Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automati... | notebooklm | notebooklm, skill, query, google, notebooks, directly, claude, code, source, grounded, citation, backed |
+| `observability-engineer` | Build production-ready monitoring, logging, and tracing systems. Implements comprehensive observability strategies, SLI/SLO management, and incident response... | observability | observability, engineer, monitoring, logging, tracing, implements, sli, slo, incident, response, proactively, infrastructure |
+| `openapi-spec-generation` | Generate and maintain OpenAPI 3.1 specifications from code, design-first specs, and validation patterns. Use when creating API documentation, generating SDKs... | openapi, spec, generation | openapi, spec, generation, generate, maintain, specifications, code, first, specs, validation, creating, api |
+| `payment-integration` | Integrate Stripe, PayPal, and payment processors. Handles checkout flows, subscriptions, webhooks, and PCI compliance. Use PROACTIVELY when implementing paym... | payment, integration | payment, integration, integrate, stripe, paypal, processors, checkout, flows, subscriptions, webhooks, pci, compliance |
+| `pci-compliance` | Implement PCI DSS compliance requirements for secure handling of payment card data and payment systems. Use when securing payment processing, achieving PCI c... | pci, compliance | pci, compliance, dss, requirements, secure, handling, payment, card, data, securing, processing, achieving |
+| `pentest-checklist` | This skill should be used when the user asks to "plan a penetration test", "create a security assessment checklist", "prepare for penetration testing", "defi... | pentest, checklist | pentest, checklist, skill, should, used, user, asks, plan, penetration, test, security, assessment |
+| `plaid-fintech` | Expert patterns for Plaid API integration including Link token flows, transactions sync, identity verification, Auth for ACH, balance checks, webhook handlin... | plaid, fintech | plaid, fintech, api, integration, including, link, token, flows, transactions, sync, identity, verification |
+| `popup-cro` | Create and optimize popups, modals, overlays, slide-ins, and banners to increase conversions without harming user experience or brand trust. | popup, cro | popup, cro, optimize, popups, modals, overlays, slide, ins, banners, increase, conversions, without |
+| `postmortem-writing` | Write effective blameless postmortems with root cause analysis, timelines, and action items. Use when conducting incident reviews, writing postmortem documen... | postmortem, writing | postmortem, writing, write, effective, blameless, postmortems, root, cause, analysis, timelines, action, items |
+| `quant-analyst` | Build financial models, backtest trading strategies, and analyze market data. Implements risk metrics, portfolio optimization, and statistical arbitrage. Use... | quant, analyst | quant, analyst, financial, models, backtest, trading, analyze, market, data, implements, risk, metrics |
+| `red-team-tactics` | Red team tactics principles based on MITRE ATT&CK. Attack phases, detection evasion, reporting. | red, team, tactics | red, team, tactics, principles, mitre, att, ck, attack, phases, detection, evasion, reporting |
+| `red-team-tools` | This skill should be used when the user asks to "follow red team methodology", "perform bug bounty hunting", "automate reconnaissance", "hunt for XSS vulnera... | red, team | red, team, methodology, skill, should, used, user, asks, follow, perform, bug, bounty |
+| `research-engineer` | An uncompromising Academic Research Engineer. Operates with absolute scientific rigor, objective criticism, and zero flair. Focuses on theoretical correctnes... | research | research, engineer, uncompromising, academic, operates, absolute, scientific, rigor, objective, criticism, zero, flair |
+| `reverse-engineer` | Expert reverse engineer specializing in binary analysis, disassembly, decompilation, and software analysis. Masters IDA Pro, Ghidra, radare2, x64dbg, and mod... | reverse | reverse, engineer, specializing, binary, analysis, disassembly, decompilation, software, masters, ida, pro, ghidra |
+| `risk-manager` | Monitor portfolio risk, R-multiples, and position limits. Creates hedging strategies, calculates expectancy, and implements stop-losses. Use PROACTIVELY for ... | risk, manager | risk, manager, monitor, portfolio, multiples, position, limits, creates, hedging, calculates, expectancy, implements |
+| `risk-metrics-calculation` | Calculate portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Use when measuring portfolio risk, implementing risk limits, or... | risk, metrics, calculation | risk, metrics, calculation, calculate, portfolio, including, var, cvar, sharpe, sortino, drawdown, analysis |
+| `sast-configuration` | Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, ... | sast, configuration | sast, configuration, configure, static, application, security, testing, automated, vulnerability, detection, code, setting |
+| `scanning-tools` | This skill should be used when the user asks to "perform vulnerability scanning", "scan networks for open ports", "assess web application security", "scan wi... | scanning | scanning, security, skill, should, used, user, asks, perform, vulnerability, scan, networks, open |
+| `secrets-management` | Implement secure secrets management for CI/CD pipelines using Vault, AWS Secrets Manager, or native platform solutions. Use when handling sensitive credentia... | secrets | secrets, secure, ci, cd, pipelines, vault, aws, manager, native, platform, solutions, handling |
+| `security-auditor` | Expert security auditor specializing in DevSecOps, comprehensive cybersecurity, and compliance frameworks. Masters vulnerability assessment, threat modeling,... | security, auditor | security, auditor, specializing, devsecops, cybersecurity, compliance, frameworks, masters, vulnerability, assessment, threat, modeling |
+| `security-compliance-compliance-check` | You are a compliance expert specializing in regulatory requirements for software systems including GDPR, HIPAA, SOC2, PCI-DSS, and other industry standards. ... | security, compliance, check | security, compliance, check, specializing, regulatory, requirements, software, including, gdpr, hipaa, soc2, pci |
+| `security-requirement-extraction` | Derive security requirements from threat models and business context. Use when translating threats into actionable requirements, creating security user stori... | security, requirement, extraction | security, requirement, extraction, derive, requirements, threat, models, business, context, translating, threats, actionable |
+| `security-scanning-security-dependencies` | You are a security expert specializing in dependency vulnerability analysis, SBOM generation, and supply chain security. Scan project dependencies across eco... | security, scanning, dependencies | security, scanning, dependencies, specializing, dependency, vulnerability, analysis, sbom, generation, supply, chain, scan |
+| `security-scanning-security-hardening` | Coordinate multi-layer security scanning and hardening across application, infrastructure, and compliance controls. | security, scanning, hardening | security, scanning, hardening, coordinate, multi, layer, application, infrastructure, compliance, controls |
+| `security-scanning-security-sast` | Static Application Security Testing (SAST) for code vulnerability analysis across multiple languages and frameworks | security, scanning, sast | security, scanning, sast, static, application, testing, code, vulnerability, analysis, multiple, languages, frameworks |
+| `seo-authority-builder` | Analyzes content for E-E-A-T signals and suggests improvements to build authority and trust. Identifies missing credibility elements. Use PROACTIVELY for YMY... | seo, authority, builder | seo, authority, builder, analyzes, content, signals, suggests, improvements, trust, identifies, missing, credibility |
+| `service-mesh-expert` | Expert service mesh architect specializing in Istio, Linkerd, and cloud-native networking patterns. Masters traffic management, security policies, observabil... | service, mesh | service, mesh, architect, specializing, istio, linkerd, cloud, native, networking, masters, traffic, security |
+| `smtp-penetration-testing` | This skill should be used when the user asks to "perform SMTP penetration testing", "enumerate email users", "test for open mail relays", "grab SMTP banners"... | smtp, penetration | smtp, penetration, testing, skill, should, used, user, asks, perform, enumerate, email, users |
+| `solidity-security` | Master smart contract security best practices to prevent common vulnerabilities and implement secure Solidity patterns. Use when writing smart contracts, aud... | solidity, security | solidity, security, smart, contract, prevent, common, vulnerabilities, secure, writing, contracts, auditing, existing |
+| `sql-injection-testing` | This skill should be used when the user asks to "test for SQL injection vulnerabilities", "perform SQLi attacks", "bypass authentication using SQL injection"... | sql, injection | sql, injection, testing, skill, should, used, user, asks, test, vulnerabilities, perform, sqli |
+| `ssh-penetration-testing` | This skill should be used when the user asks to "pentest SSH services", "enumerate SSH configurations", "brute force SSH credentials", "exploit SSH vulnerabi... | ssh, penetration | ssh, penetration, testing, skill, should, used, user, asks, pentest, enumerate, configurations, brute |
+| `stride-analysis-patterns` | Apply STRIDE methodology to systematically identify threats. Use when analyzing system security, conducting threat modeling sessions, or creating security do... | stride | stride, analysis, apply, methodology, systematically, identify, threats, analyzing, security, conducting, threat, modeling |
+| `stripe-integration` | Implement Stripe payment processing for robust, PCI-compliant payment flows including checkout, subscriptions, and webhooks. Use when integrating Stripe paym... | stripe, integration | stripe, integration, payment, processing, robust, pci, compliant, flows, including, checkout, subscriptions, webhooks |
+| `terraform-specialist` | Expert Terraform/OpenTofu specialist mastering advanced IaC automation, state management, and enterprise infrastructure patterns. Handles complex module desi... | terraform | terraform, opentofu, mastering, iac, automation, state, enterprise, infrastructure, complex, module, multi, cloud |
+| `threat-mitigation-mapping` | Map identified threats to appropriate security controls and mitigations. Use when prioritizing security investments, creating remediation plans, or validatin... | threat, mitigation, mapping | threat, mitigation, mapping, map, identified, threats, appropriate, security, controls, mitigations, prioritizing, investments |
+| `threat-modeling-expert` | Expert in threat modeling methodologies, security architecture review, and risk assessment. Masters STRIDE, PASTA, attack trees, and security requirement ext... | threat, modeling | threat, modeling, methodologies, security, architecture, review, risk, assessment, masters, stride, pasta, attack |
+| `top-web-vulnerabilities` | This skill should be used when the user asks to "identify web application vulnerabilities", "explain common security flaws", "understand vulnerability catego... | top, web, vulnerabilities | top, web, vulnerabilities, 100, reference, skill, should, used, user, asks, identify, application |
+| `twilio-communications` | Build communication features with Twilio: SMS messaging, voice calls, WhatsApp Business API, and user verification (2FA). Covers the full spectrum from simpl... | twilio, communications | twilio, communications, communication, features, sms, messaging, voice, calls, whatsapp, business, api, user |
+| `ui-visual-validator` | Rigorous visual validation expert specializing in UI testing, design system compliance, and accessibility verification. Masters screenshot analysis, visual r... | ui, visual, validator | ui, visual, validator, rigorous, validation, specializing, testing, compliance, accessibility, verification, masters, screenshot |
+| `vulnerability-scanner` | Advanced vulnerability analysis principles. OWASP 2025, Supply Chain Security, attack surface mapping, risk prioritization. | vulnerability, scanner | vulnerability, scanner, analysis, principles, owasp, 2025, supply, chain, security, attack, surface, mapping |
+| `web-design-guidelines` | Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my si... | web, guidelines | web, guidelines, review, ui, code, interface, compliance, asked, my, check, accessibility, audit |
+| `wordpress-penetration-testing` | This skill should be used when the user asks to "pentest WordPress sites", "scan WordPress for vulnerabilities", "enumerate WordPress users, themes, or plugi... | wordpress, penetration | wordpress, penetration, testing, skill, should, used, user, asks, pentest, sites, scan, vulnerabilities |
+| `xss-html-injection` | This skill should be used when the user asks to "test for XSS vulnerabilities", "perform cross-site scripting attacks", "identify HTML injection flaws", "exp... | xss, html, injection | xss, html, injection, cross, site, scripting, testing, skill, should, used, user, asks |
+
+## testing (21)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `ab-test-setup` | Structured guide for setting up A/B tests with mandatory gates for hypothesis, metrics, and execution readiness. | ab, setup | ab, setup, test, structured, setting, up, tests, mandatory, gates, hypothesis, metrics, execution |
+| `conductor-implement` | Execute tasks from a track's implementation plan following TDD workflow | conductor, implement | conductor, implement, execute, tasks, track, plan, following, tdd |
+| `conductor-revert` | Git-aware undo by logical work unit (track, phase, or task) | conductor, revert | conductor, revert, git, aware, undo, logical, work, unit, track, phase, task |
+| `debugger` | Debugging specialist for errors, test failures, and unexpected behavior. Use proactively when encountering any issues. | debugger | debugger, debugging, errors, test, failures, unexpected, behavior, proactively, encountering, any, issues |
+| `dependency-upgrade` | Manage major dependency version upgrades with compatibility analysis, staged rollout, and comprehensive testing. Use when upgrading framework versions, updat... | dependency, upgrade | dependency, upgrade, major, version, upgrades, compatibility, analysis, staged, rollout, testing, upgrading, framework |
+| `pentest-commands` | This skill should be used when the user asks to "run pentest commands", "scan with nmap", "use metasploit exploits", "crack passwords with hydra or john", "s... | pentest, commands | pentest, commands, skill, should, used, user, asks, run, scan, nmap, metasploit, exploits |
+| `performance-testing-review-multi-agent-review` | Use when working with performance testing review multi agent review | performance, multi, agent | performance, multi, agent, testing, review, working |
+| `playwright-skill` | Complete browser automation with Playwright. Auto-detects dev servers, writes clean test scripts to /tmp. Test pages, fill forms, take screenshots, check res... | playwright, skill | playwright, skill, complete, browser, automation, auto, detects, dev, servers, writes, clean, test |
+| `screen-reader-testing` | Test web applications with screen readers including VoiceOver, NVDA, and JAWS. Use when validating screen reader compatibility, debugging accessibility issue... | screen, reader | screen, reader, testing, test, web, applications, readers, including, voiceover, nvda, jaws, validating |
+| `startup-analyst` | Expert startup business analyst specializing in market sizing, financial modeling, competitive analysis, and strategic planning for early-stage companies. Us... | startup, analyst | startup, analyst, business, specializing, market, sizing, financial, modeling, competitive, analysis, strategic, planning |
+| `startup-metrics-framework` | This skill should be used when the user asks about "key startup metrics", "SaaS metrics", "CAC and LTV", "unit economics", "burn multiple", "rule of 40", "ma... | startup, metrics, framework | startup, metrics, framework, skill, should, used, user, asks, about, key, saas, cac |
+| `systematic-debugging` | Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes | systematic, debugging | systematic, debugging, encountering, any, bug, test, failure, unexpected, behavior, before, proposing, fixes |
+| `tdd-workflow` | Test-Driven Development workflow principles. RED-GREEN-REFACTOR cycle. | tdd | tdd, test, driven, development, principles, red, green, refactor, cycle |
+| `tdd-workflows-tdd-cycle` | Use when working with tdd workflows tdd cycle | tdd, cycle | tdd, cycle, working |
+| `tdd-workflows-tdd-green` | Implement the minimal code needed to make failing tests pass in the TDD green phase. | tdd, green | tdd, green, minimal, code, needed, failing, tests, pass, phase |
+| `tdd-workflows-tdd-red` | Generate failing tests for the TDD red phase to define expected behavior and edge cases. | tdd, red | tdd, red, generate, failing, tests, phase, define, expected, behavior, edge, cases |
+| `tdd-workflows-tdd-refactor` | Use when working with tdd workflows tdd refactor | tdd, refactor | tdd, refactor, working |
+| `test-driven-development` | Use when implementing any feature or bugfix, before writing implementation code | driven | driven, test, development, implementing, any, feature, bugfix, before, writing, code |
+| `test-fixing` | Run tests and systematically fix all failing tests using smart error grouping. Use when user asks to fix failing tests, mentions test failures, runs test sui... | fixing | fixing, test, run, tests, systematically, fix, all, failing, smart, error, grouping, user |
+| `unit-testing-test-generate` | Generate comprehensive, maintainable unit tests across languages with strong coverage and edge case focus. | unit, generate | unit, generate, testing, test, maintainable, tests, languages, strong, coverage, edge, case |
+| `web3-testing` | Test smart contracts comprehensively using Hardhat and Foundry with unit tests, integration tests, and mainnet forking. Use when testing Solidity contracts, ... | web3 | web3, testing, test, smart, contracts, comprehensively, hardhat, foundry, unit, tests, integration, mainnet |
+
+## workflow (17)
+
+| Skill | Description | Tags | Triggers |
+| --- | --- | --- | --- |
+| `agent-orchestration-improve-agent` | Systematic improvement of existing agents through performance analysis, prompt engineering, and continuous iteration. | agent, improve | agent, improve, orchestration, systematic, improvement, existing, agents, through, performance, analysis, prompt, engineering |
+| `agent-orchestration-multi-agent-optimize` | Optimize multi-agent systems with coordinated profiling, workload distribution, and cost-aware orchestration. Use when improving agent performance, throughpu... | agent, multi, optimize | agent, multi, optimize, orchestration, coordinated, profiling, workload, distribution, cost, aware, improving, performance |
+| `billing-automation` | Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing... | billing | billing, automation, automated, recurring, payments, invoicing, subscription, lifecycle, dunning, implementing, automating, managing |
+| `changelog-automation` | Automate changelog generation from commits, PRs, and releases following Keep a Changelog format. Use when setting up release workflows, generating release no... | changelog | changelog, automation, automate, generation, commits, prs, releases, following, keep, format, setting, up |
+| `conductor-manage` | Manage track lifecycle: archive, restore, delete, rename, and cleanup | conductor, manage | conductor, manage, track, lifecycle, archive, restore, delete, rename, cleanup |
+| `conductor-new-track` | Create a new track with specification and phased implementation plan | conductor, new, track | conductor, new, track, specification, phased, plan |
+| `conductor-status` | Display project status, active tracks, and next actions | conductor, status | conductor, status, display, active, tracks, next, actions |
+| `conductor-validator` | Validates Conductor project artifacts for completeness, consistency, and correctness. Use after setup, when diagnosing issues, or before implementation to ve... | conductor, validator | conductor, validator, validates, artifacts, completeness, consistency, correctness, after, setup, diagnosing, issues, before |
+| `email-sequence` | When the user wants to create or optimize an email sequence, drip campaign, automated email flow, or lifecycle email program. Also use when the user mentions... | email, sequence | email, sequence, user, wants, optimize, drip, campaign, automated, flow, lifecycle, program, mentions |
+| `full-stack-orchestration-full-stack-feature` | Use when working with full stack orchestration full stack feature | full, stack | full, stack, orchestration, feature, working |
+| `git-pushing` | Stage, commit, and push git changes with conventional commit messages. Use when user wants to commit and push changes, mentions pushing to remote, or asks to... | git, pushing | git, pushing, stage, commit, push, changes, conventional, messages, user, wants, mentions, remote |
+| `kaizen` | Guide for continuous improvement, error proofing, and standardization. Use this skill when the user wants to improve code quality, refactor, or discuss proce... | kaizen | kaizen, continuous, improvement, error, proofing, standardization, skill, user, wants, improve, code, quality |
+| `mermaid-expert` | Create Mermaid diagrams for flowcharts, sequences, ERDs, and architectures. Masters syntax for all diagram types and styling. Use PROACTIVELY for visual docu... | mermaid | mermaid, diagrams, flowcharts, sequences, erds, architectures, masters, syntax, all, diagram, types, styling |
+| `pdf` | Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs ... | pdf | pdf, manipulation, toolkit, extracting, text, tables, creating, new, pdfs, merging, splitting, documents |
+| `pdf-official` | Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs ... | pdf, official | pdf, official, manipulation, toolkit, extracting, text, tables, creating, new, pdfs, merging, splitting |
+| `team-collaboration-issue` | You are a GitHub issue resolution expert specializing in systematic bug investigation, feature implementation, and collaborative development workflows. Your ... | team, collaboration, issue | team, collaboration, issue, github, resolution, specializing, systematic, bug, investigation, feature, collaborative, development |
+| `track-management` | Use this skill when creating, managing, or working with Conductor tracks - the logical work units for features, bugs, and refactors. Applies to spec.md, plan... | track | track, skill, creating, managing, working, conductor, tracks, logical, work, units, features, bugs |

CHANGELOG.md

@@ -7,6 +7,266 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+---
+
+---
+
+## [4.0.0] - 2026-01-28 - "The Enterprise Era"
+
+> **A massive integration of 300+ Enterprise skills, transforming Antigravity into a complete operating system for AI agents.**
+
+### Added
+
+- **Massive Skill Injection**: Merged 300+ Enterprise skills from `rmyndharis/antigravity-skills`.
+- **New Categories**:
+  - **Architecture & Design**: `backend-architect`, `c4-architecture`.
+  - **Data & AI**: `rag-engineer`, `langchain-architecture`.
+  - **Security**: `security-auditor`, `cloud-pentesting`.
+- **Catalog System**: Introduced `CATALOG.md` and `scripts/build-catalog.js` for automated, table-based skill discovery.
+
+### Changed
+
+- **Documentation Overhaul**:
+  - Removed the legacy 250+ row skill table from `README.md`.
+  - Restructured `README.md` to focus on high-level domains.
+  - Replaced static registry with dynamic `CATALOG.md`.
+- **Version Bump**: Major version update to 4.0.0 reflecting the doubling of skill capacity (247 -> 550+).
+
+### Credits
+
+- **[@rmyndharis](https://github.com/rmyndharis)** - For the massive contribution of 300+ Enterprise skills and valid catalog logic.
+- **[@sstklen](https://github.com/sstklen)** & **[@rookie-ricardo](https://github.com/rookie-ricard)** - Continued community support.
+
+## [3.4.0] - 2026-01-27 - "Voice Intelligence & Categorization"
+
+### Added
+
+- **New Skill**: `voice-ai-engine-development` - Complete toolkit for building real-time voice agents (OpenAI Realtime, Vapi, Deepgram, ElevenLabs).
+- **Categorization**: Major README update introducing a concise "Features & Categories" summary table.
+
+### Changed
+
+- **README**: Replaced text-heavy category lists with a high-level summary table.
+- **Registry**: Synced generic skill count (256) across documentation.
+
+### Contributors
+
+- [@sickn33](https://github.com/sickn33) - Voice AI Engine (PR #33)
+- [@community](https://github.com/community) - Categorization Initiative (PR #32)
+
+## [3.3.0] - 2026-01-26 - "News & Research"
+
+### Added
+
+- **New Skills**:
+  - `last30days`: Research any topic from the last 30 days on Reddit + X + Web.
+  - `daily-news-report`: Generate daily news reports from multiple sources.
+
+### Changed
+
+- **Registry**: Updated `skills_index.json` and `README.md` registry (Total: 255 skills).
+
+## [3.2.0] - 2026-01-26 - "Clarity & Consistency"
+
+### Changed
+
+- **Skills Refactoring**: Significant overhaul of `backend-dev-guidelines`, `frontend-design`, `frontend-dev-guidelines`, and `mobile-design`.
+  - **Consolidation**: Merged fragmented documentation into single, authoritative `SKILL.md` files.
+  - **Final Laws**: Introduced "Final Laws" sections to provide strict, non-negotiable decision frameworks.
+  - **Simplification**: Removed external file dependencies to improve context retrieval for AI agents.
+
+### Fixed
+
+- **Validation**: Fixed critical YAML frontmatter formatting issues in `seo-fundamentals`, `programmatic-seo`, and `schema-markup` that were blocking strict validation.
+- **Merge Conflicts**: Resolved text artifact conflicts in SEO skills.
+
+## [3.1.0] - 2026-01-26 - "Stable & Deterministic"
+
+### Fixed
+
+- **CI/CD Drift**: Resolved persistent "Uncommitted Changes" errors in CI by making the index generation script deterministic (sorting by name + ID).
+- **Registry Sync**: Synced `README.md` and `skills_index.json` to accurately reflect all 253 skills.
+
+### Added (Registry Restore)
+
+The following skills are now correctly indexed and visible in the registry:
+
+- **Marketing & Growth**: `programmatic-seo`, `schema-markup`, `seo-fundamentals`, `form-cro`, `popup-cro`, `analytics-tracking`.
+- **Security**: `windows-privilege-escalation`, `wireshark-analysis`, `wordpress-penetration-testing`, `writing-plans`.
+- **Development**: `tdd-workflow`, `web-performance-optimization`, `webapp-testing`, `workflow-automation`, `zapier-make-patterns`.
+- **Maker Tools**: `telegram-bot-builder`, `telegram-mini-app`, `viral-generator-builder`.
+
+### Changed
+
+- **Documentation**: Added `docs/CI_DRIFT_FIX.md` as a canonical reference for resolving drift issues.
+- **Guidance**: Updated `docs/GETTING_STARTED.md` counts to match the full registry (253+ skills).
+- **Maintenance**: Updated `MAINTENANCE.md` with strict protocols for handling generated files.
+
+## [3.0.0] - 2026-01-25 - "The Governance Update"
+
+### Added
+
+- **Governance & Security**:
+  - `docs/QUALITY_BAR.md`: Defined 5-point validation standard (Metadata, Risk, Triggers).
+  - `docs/SECURITY_GUARDRAILS.md`: Enforced "Authorized Use Only" for offensive skills.
+  - `CODE_OF_CONDUCT.md`: Adhered to Contributor Covenant v2.1.
+- **Automation**:
+  - `scripts/validate_skills.py`: Automated Quality Bar enforcement (Soft Mode supported).
+  - `.github/workflows/ci.yml`: Automated PR checks.
+  - `scripts/generate_index.py`: Registry generation with Risk & Source columns.
+- **Experience**:
+  - `docs/BUNDLES.md`: 9 Starter Packs (Essentials, Security, Web, Agent, Game Dev, DevOps, Data, Testing, Creative).
+  - **Interactive Registry**: README now features Risk Levels (🔴/🟢/🟣) and Collections.
+- **Documentation**:
+  - `docs/EXAMPLES.md`: Cookbook with 3 real-world scenarios.
+  - `docs/SOURCES.md`: Legal ledger for attributions and licenses.
+  - `RELEASE_NOTES.md`: Generated release announcement (archived).
+
+### Changed
+
+- **Standardization**: All 250+ skills are now validated against the new Quality Bar schema.
+- **Project Structure**: Introduced `docs/` folder for scalable documentation.
+
+## [2.14.0] - 2026-01-25 - "Web Intelligence & Windows"
+
+### Added
+
+- **New Skill**:
+  - `context7-auto-research`: Auto-research capability for Claude Code.
+  - `codex-review`: Professional code review with AI integration.
+  - `exa-search`: Semantic search and discovery using Exa API.
+  - `firecrawl-scraper`: Deep web scraping and PDF parsing.
+  - `tavily-web`: Content extraction and research using Tavily.
+  - `busybox-on-windows`: UNIX tool suite for Windows environments.
+
+### Changed
+
+- **Documentation**: Updated `obsidian-clipper-template-creator` docs and templates.
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry.
+
+### Fixed
+
+- **Skills**: Fixed YAML frontmatter quoting in `lint-and-validate`.
+
+## [2.13.0] - 2026-01-24 - "NoSQL Expert"
+
+### Added
+
+- **New Skill**:
+  - `nosql-expert`: Expert guidance for distributed NoSQL databases (Cassandra, DynamoDB), focusing on query-first modeling and anti-patterns.
+
+### Changed
+
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry.
+
+### Contributors
+
+- [@sickn33](https://github.com/sickn33) - PR #23
+
+## [2.12.0] - 2026-01-23 - "Enterprise & UI Power"
+
+### Added
+
+- **New Skills**:
+  - `production-code-audit`: Comprehensive enterprise auditing skill for production readiness.
+  - `avalonia-layout-zafiro`: Zafiro layout guidelines for Avalonia UI.
+  - `avalonia-viewmodels-zafiro`: ViewModel composition patterns for Avalonia.
+  - `avalonia-zafiro-development`: Core development rules for Avalonia Zafiro applications.
+
+### Changed
+
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry (Total: 243 skills).
+
+### Contributors
+
+- [@SuperJMN](https://github.com/SuperJMN) - PR #20
+- [@Mohammad-Faiz-Cloud-Engineer](https://github.com/Mohammad-Faiz-Cloud-Engineer) - PR #21
+
+## [2.11.0] - 2026-01-23 - "Postgres Performance"
+
+### Added
+
+- **New Skill**:
+  - `postgres-best-practices`: Comprehensive Supabase PostgreSQL performance optimization guide with 30+ rules covering query performance, connection management, RLS security, schema design, locking, and monitoring.
+
+### Changed
+
+- **Official Sources**: Added [supabase/agent-skills](https://github.com/supabase/agent-skills) to Credits & Sources.
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry (Total: 239 skills).
+
+### Contributors
+
+- [@ar27111994](https://github.com/ar27111994) - PR #19
+
+---
+
+## [2.10.0] - 2026-01-22 - "Developer Excellence"
+
+### Added
+
+- **New Skills**:
+  - `api-security-best-practices`: Comprehensive guide for secure API design and defense.
+  - `environment-setup-guide`: Systematic approach to project onboarding and tool configuration.
+  - `web-performance-optimization`: Methodologies for optimizing Core Web Vitals and loading speed.
+
+### Changed
+
+- **Enhanced Skill**:
+  - `code-review-checklist`: Replaced with a much more detailed and systematic version covering functionality, security, and quality.
+
+### Fixed
+
+- **Index & Registry**: Updated `skills_index.json` and `README.md` registry (Total: 238 skills).
+
+### Added
+
+- **Automation Support**:
+  - `scripts/update_readme.py`: Automated script to sync skill counts and regenerate the registry table.
+  - Updated `MAINTENANCE.md` to reflect the new automated workflow.
+- **Repository Quality**:
+  - `MAINTENANCE.md` is now tracked in the repository (removed from `.gitignore`).
+  - Improved contribution guidelines.
+
+## [2.8.0] - 2026-01-22 - "Documentation Power"
+
+### Added
+
+- **API Documentation Generator**: New skill to automatically generate comprehensive API documentation (`skills/api-documentation-generator`).
+- **Remotion Best Practices**: 28 modular rules for programmatic video creation (`skills/remotion-best-practices`).
+
+## [2.7.0] - 2026-01-22 - "Agent Memory"
+
+### Added
+
+- **Agent Memory MCP**: New skill providing persistent, searchable knowledge management for AI agents (`skills/agent-memory-mcp`).
+
+### Changed
+
+- **Renamed Skill**: `agent-memory` was renamed to `agent-memory-mcp` to avoid naming conflicts.
+
+---
+
+## [2.6.0] - 2026-01-21 - "Everything Skills Edition"
+
+### Added
+
+- **8 Verified Skills** from [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code):
+  - `cc-skill-backend-patterns`
+  - `cc-skill-clickhouse-io`
+  - `cc-skill-coding-standards`
+  - `cc-skill-continuous-learning`
+  - `cc-skill-frontend-patterns`
+  - `cc-skill-project-guidelines-example`
+  - `cc-skill-security-review`
+  - `cc-skill-strategic-compact`
+- **Documentation**: New `docs/WALKTHROUGH.md` for import process details.
+
+### Changed
+
+- **Skill Cleanup**: Removed 27 unwanted agents, commands, and rules from the `everything-claude-code` import to focus strictly on skills.
+- **Index**: Regenerated `skills_index.json` (Total: 233 skills).
+- **Credits**: Updated README credits and registry.
+
 ## [1.0.0] - 2026-01-19 - "Marketing Edition"
 
 ### Added
@@ -113,7 +373,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- Total skills count: ~65
+- Total skills count: **~65**
 
 ---
 

CONTRIBUTING.md

@@ -1,6 +1,19 @@
-# 🤝 Contributing Guide - Make It Easy for Everyone!
+# 🤝 Contributing Guide - V3 Enterprise Edition
 
 **Thank you for wanting to make this repo better!** This guide shows you exactly how to contribute, even if you're new to open source.
+With V3, we raised the bar for quality. Please read the **new Quality Standards** below carefully.
+
+---
+
+## 🧐 The "Quality Bar" (V3 Standard)
+
+**Critical for new skills:** Every skill submitted must pass our **5-Point Quality Check** (see `docs/QUALITY_BAR.md` for details):
+
+1.  **Metadata**: Correct Frontmatter (`name`, `description`).
+2.  **Safety**: No harmful commands without "Risk" labels.
+3.  **Clarity**: Clear "When to use" section.
+4.  **Examples**: At least one copy-paste usage example.
+5.  **Actions**: Must define concrete steps, not just "thoughts".
 
 ---
 
@@ -9,104 +22,60 @@
 You don't need to be an expert! Here are ways anyone can help:
 
 ### 1. Improve Documentation (Easiest!)
+
 - Fix typos or grammar
 - Make explanations clearer
 - Add examples to existing skills
 - Translate documentation to other languages
 
 ### 2. Report Issues
+
 - Found something confusing? Tell us!
 - Skill not working? Let us know!
 - Have suggestions? We want to hear them!
 
 ### 3. Create New Skills
+
 - Share your expertise as a skill
 - Fill gaps in the current collection
 - Improve existing skills
 
 ### 4. Test and Validate
+
 - Try skills and report what works/doesn't work
 - Test on different AI tools
 - Suggest improvements
 
 ---
 
-## How to Improve Documentation
-
-### Super Easy Method (No Git Knowledge Needed!)
-
-1. **Find the file** you want to improve on GitHub
-2. **Click the pencil icon** (✏️) to edit
-3. **Make your changes** in the browser
-4. **Click "Propose changes"** at the bottom
-5. **Done!** We'll review and merge it
-
-### Using Git (If You Know How)
-
-```bash
-# 1. Fork the repo on GitHub (click the Fork button)
-
-# 2. Clone your fork
-git clone https://github.com/YOUR-USERNAME/antigravity-awesome-skills.git
-cd antigravity-awesome-skills
-
-# 3. Create a branch
-git checkout -b improve-docs
-
-# 4. Make your changes
-# Edit files in your favorite editor
-
-# 5. Commit and push
-git add .
-git commit -m "docs: make XYZ clearer"
-git push origin improve-docs
-
-# 6. Open a Pull Request on GitHub
-```
-
----
-
 ## How to Create a New Skill
 
-### What Makes a Good Skill?
-
-A skill should:
-- ✅ Solve a specific problem
-- ✅ Be reusable across projects
-- ✅ Have clear instructions
-- ✅ Include examples when possible
-
-### Step-by-Step: Create Your First Skill
+### Step-by-Step Guide
 
 #### Step 1: Choose Your Skill Topic
 
-Ask yourself:
-- What am I good at?
-- What do I wish my AI assistant knew better?
-- What task do I do repeatedly?
-
-**Examples:**
-- "I'm good at Docker, let me create a Docker skill"
-- "I wish AI understood Tailwind better"
-- "I keep setting up the same testing patterns"
+Ask yourself: "What do I wish my AI assistant knew better?".
+Example: "I'm good at Docker, let me create a Docker skill".
 
 #### Step 2: Create the Folder Structure
 
+Skills live in the `skills/` directory. Use `kebab-case` for folder names.
+
 ```bash
-# Navigate to the skills directory
+# Navigate to skills
 cd skills/
 
-# Create your skill folder (use lowercase with hyphens)
+# Create your skill folder
 mkdir my-awesome-skill
+cd my-awesome-skill
 
 # Create the SKILL.md file
-cd my-awesome-skill
 touch SKILL.md
 ```
 
 #### Step 3: Write Your SKILL.md
 
-Every skill needs this basic structure:
+Every skill needs this basic structure. **Copy this template:**
 
 ```markdown
 ---
@@ -124,90 +93,50 @@ Explain what this skill does and when to use it.
 
 - Use when [scenario 1]
 - Use when [scenario 2]
-- Use when [scenario 3]
 
 ## How It Works
 
-### Step 1: [First Step]
-Explain what to do first...
-
-### Step 2: [Second Step]
-Explain the next step...
-
-### Step 3: [Final Step]
-Explain how to finish...
+Detailed step-by-step instructions for the AI...
 
 ## Examples
 
-### Example 1: [Common Use Case]
-\`\`\`
-Show example code or commands here
-\`\`\`
+### Example 1
 
-### Example 2: [Another Use Case]
 \`\`\`
-More examples...
+code example here
 \`\`\`
 
 ## Best Practices
 
 - ✅ Do this
-- ✅ Also do this
 - ❌ Don't do this
-- ❌ Avoid this
-
-## Common Pitfalls
-
-- **Problem:** Description of common issue
-  **Solution:** How to fix it
-
-## Additional Resources
-
-- [Link to documentation](https://example.com)
-- [Tutorial](https://example.com)
 ```
 
-#### Step 4: Test Your Skill
+#### Step 4: Validate (CRITICAL V3 STEP)
 
-1. **Copy it to your AI tool's skills directory:**
-   ```bash
-   cp -r skills/my-awesome-skill ~/.agent/skills/
-   ```
-
-2. **Try using it:**
-   ```
-   @my-awesome-skill help me with [task]
-   ```
-
-3. **Does it work?** Great! If not, refine it.
-
-#### Step 5: Validate Your Skill
-
-Run the validation script:
+Run the validation script locally. **We will not merge PRs that fail this check.**
 
 ```bash
+# Soft mode (warnings only)
 python3 scripts/validate_skills.py
+
+# Hard mode (what CI runs)
+python3 scripts/validate_skills.py --strict
 ```
 
 This checks:
-- ✅ SKILL.md exists
+
+- ✅ `SKILL.md` exists
 - ✅ Frontmatter is correct
 - ✅ Name matches folder name
-- ✅ Description exists
+- ✅ Quality Bar checks passed
 
-#### Step 6: Submit Your Skill
+#### Step 5: Submit Your Skill
 
 ```bash
-# 1. Add your skill
 git add skills/my-awesome-skill/
-
-# 2. Commit with a clear message
-git commit -m "feat: add my-awesome-skill for [purpose]"
-
-# 3. Push to your fork
+git commit -m "feat: add my-awesome-skill"
 git push origin my-branch
-
-# 4. Open a Pull Request on GitHub
 ```
 
 ---
@@ -232,110 +161,34 @@ description: "One sentence describing what this skill does and when to use it"
 
 - Use when you need to [scenario 1]
 - Use when you want to [scenario 2]
-- Use when working with [scenario 3]
-
-## Core Concepts
-
-### Concept 1
-[Explain key concept]
-
-### Concept 2
-[Explain another key concept]
 
 ## Step-by-Step Guide
 
 ### 1. [First Step Name]
-[Detailed instructions]
 
-### 2. [Second Step Name]
-[Detailed instructions]
-
-### 3. [Third Step Name]
 [Detailed instructions]
 
 ## Examples
 
 ### Example 1: [Use Case Name]
+
 \`\`\`language
 // Example code here
 \`\`\`
 
-**Explanation:** [What this example demonstrates]
-
-### Example 2: [Another Use Case]
-\`\`\`language
-// More example code
-\`\`\`
-
-**Explanation:** [What this example demonstrates]
-
 ## Best Practices
 
 - ✅ **Do:** [Good practice]
-- ✅ **Do:** [Another good practice]
 - ❌ **Don't:** [What to avoid]
-- ❌ **Don't:** [Another thing to avoid]
 
 ## Troubleshooting
 
-### Problem: [Common Issue]
-**Symptoms:** [How you know this is the problem]
+**Problem:** [Common Issue]
 **Solution:** [How to fix it]
-
-### Problem: [Another Issue]
-**Symptoms:** [How you know this is the problem]
-**Solution:** [How to fix it]
-
-## Related Skills
-
-- `@related-skill-1` - [When to use this instead]
-- `@related-skill-2` - [How this complements your skill]
-
-## Additional Resources
-
-- [Official Documentation](https://example.com)
-- [Tutorial](https://example.com)
-- [Community Guide](https://example.com)
 ```
 
 ---
 
-## How to Report Issues
-
-### Found a Bug?
-
-1. **Check existing issues** - Maybe it's already reported
-2. **Open a new issue** with this info:
-   - What skill has the problem?
-   - What AI tool are you using?
-   - What did you expect to happen?
-   - What actually happened?
-   - Steps to reproduce
-
-### Found Something Confusing?
-
-1. **Open an issue** titled: "Documentation unclear: [topic]"
-2. **Explain:**
-   - What part is confusing?
-   - What did you expect to find?
-   - How could it be clearer?
-
----
-
-## Contribution Checklist
-
-Before submitting your contribution:
-
-- [ ] My skill has a clear, descriptive name
-- [ ] The `SKILL.md` has proper frontmatter (name + description)
-- [ ] I've included examples
-- [ ] I've tested the skill with an AI assistant
-- [ ] I've run `python3 scripts/validate_skills.py`
-- [ ] My commit message is clear (e.g., "feat: add docker-compose skill")
-- [ ] I've checked for typos and grammar
-
----
-
 ## Commit Message Guidelines
 
 Use these prefixes:
@@ -348,11 +201,11 @@ Use these prefixes:
 - `chore:` - Maintenance tasks
 
 **Examples:**
+
 ```
 feat: add kubernetes-deployment skill
 docs: improve getting started guide
 fix: correct typo in stripe-integration skill
-docs: add examples to react-best-practices
 ```
 
 ---
@@ -360,30 +213,13 @@ docs: add examples to react-best-practices
 ## Learning Resources
 
 ### New to Git/GitHub?
+
 - [GitHub's Hello World Guide](https://guides.github.com/activities/hello-world/)
 - [Git Basics](https://git-scm.com/book/en/v2/Getting-Started-Git-Basics)
 
 ### New to Markdown?
+
 - [Markdown Guide](https://www.markdownguide.org/basic-syntax/)
-- [GitHub Markdown](https://guides.github.com/features/mastering-markdown/)
-
-### New to Open Source?
-- [First Contributions](https://github.com/firstcontributions/first-contributions)
-- [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
-
----
-
-## Need Help?
-
-- **Questions?** Open a [Discussion](https://github.com/sickn33/antigravity-awesome-skills/discussions)
-- **Stuck?** Open an [Issue](https://github.com/sickn33/antigravity-awesome-skills/issues)
-- **Want feedback?** Open a [Draft Pull Request](https://github.com/sickn33/antigravity-awesome-skills/pulls)
-
----
-
-## Recognition
-
-All contributors are recognized in our [Contributors](https://github.com/sickn33/antigravity-awesome-skills/graphs/contributors) page!
 
 ---
 
@@ -392,10 +228,9 @@ All contributors are recognized in our [Contributors](https://github.com/sickn33
 - Be respectful and inclusive
 - Welcome newcomers
 - Focus on constructive feedback
-- Help others learn
+- **No harmful content**: See `docs/SECURITY_GUARDRAILS.md`.
 
 ---
 
 **Thank you for making this project better for everyone!**
-
 Every contribution, no matter how small, makes a difference. Whether you fix a typo, improve a sentence, or create a whole new skill - you're helping thousands of developers!

FAQ.md

@@ -1,528 +0,0 @@
-# ❓ Frequently Asked Questions (FAQ)
-
-**Got questions?** You're not alone! Here are answers to the most common questions about Antigravity Awesome Skills.
-
----
-
-## 🎯 General Questions
-
-### What are "skills" exactly?
-
-Skills are specialized instruction files that teach AI assistants how to handle specific tasks. Think of them as expert knowledge modules that your AI can load on-demand.
-
-**Simple analogy:** Just like you might consult different experts (a lawyer, a doctor, a mechanic), skills let your AI become an expert in different areas when you need them.
-
----
-
-### Do I need to install all 179 skills?
-
-**No!** When you clone the repository, all skills are available, but your AI only loads them when you explicitly invoke them with `@skill-name` or `/skill-name`.
-
-It's like having a library - all the books are there, but you only read the ones you need.
-
----
-
-### Which AI tools work with these skills?
-
-These skills work with any AI coding assistant that supports the `SKILL.md` format:
-
-- ✅ **Claude Code** (Anthropic CLI)
-- ✅ **Gemini CLI** (Google)
-- ✅ **Codex CLI** (OpenAI)
-- ✅ **Cursor** (AI IDE)
-- ✅ **Antigravity IDE**
-- ✅ **OpenCode**
-- ⚠️ **GitHub Copilot** (partial support)
-
----
-
-### Are these skills free to use?
-
-**Yes!** This repository is licensed under MIT License, which means:
-- ✅ Free for personal use
-- ✅ Free for commercial use
-- ✅ You can modify them
-- ✅ You can redistribute them
-
----
-
-### Do skills work offline?
-
-The skill files themselves are stored locally on your computer, but your AI assistant needs an internet connection to function. So:
-- ✅ Skills are local files
-- ❌ AI assistant needs internet
-
----
-
-## Installation & Setup
-
-### Where should I install the skills?
-
-The universal path that works with most tools is `.agent/skills/`:
-
-```bash
-git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
-```
-
-**Tool-specific paths:**
-- Claude Code: `.claude/skills/` or `.agent/skills/`
-- Gemini CLI: `.gemini/skills/` or `.agent/skills/`
-- Cursor: `.cursor/skills/` or project root
-- Antigravity: `.agent/skills/`
-
----
-
-### Can I install skills in multiple projects?
-
-**Yes!** You have two options:
-
-**Option 1: Global Installation** (recommended)
-Install once in your home directory, works for all projects:
-```bash
-cd ~
-git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
-```
-
-**Option 2: Per-Project Installation**
-Install in each project directory:
-```bash
-cd /path/to/your/project
-git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
-```
-
----
-
-### How do I update skills to the latest version?
-
-Navigate to your skills directory and pull the latest changes:
-
-```bash
-cd .agent/skills
-git pull origin main
-```
-
----
-
-### Can I install only specific skills?
-
-**Yes!** You can manually copy individual skill folders:
-
-```bash
-# Clone the full repo first
-git clone https://github.com/sickn33/antigravity-awesome-skills.git temp-skills
-
-# Copy only the skills you want
-mkdir -p .agent/skills
-cp -r temp-skills/skills/brainstorming .agent/skills/
-cp -r temp-skills/skills/stripe-integration .agent/skills/
-
-# Clean up
-rm -rf temp-skills
-```
-
----
-
-## Using Skills
-
-### How do I invoke a skill?
-
-Use the `@` symbol followed by the skill name:
-
-```
-@skill-name your request here
-```
-
-**Examples:**
-```
-@brainstorming help me design a todo app
-@stripe-integration add subscription billing
-@systematic-debugging fix this test failure
-```
-
-Some tools also support `/skill-name` syntax.
-
----
-
-### How do I know which skill to use?
-
-**Method 1: Browse the README**
-Check the [Full Skill Registry](README.md#full-skill-registry-179179) organized by category
-
-**Method 2: Search by keyword**
-```bash
-ls skills/ | grep "keyword"
-```
-
-**Method 3: Ask your AI**
-```
-What skills are available for [topic]?
-```
-
----
-
-### Can I use multiple skills at once?
-
-**Yes!** You can invoke multiple skills in the same conversation:
-
-```
-@brainstorming help me design this feature
-
-[After brainstorming...]
-
-@test-driven-development now let's implement it with tests
-```
-
----
-
-### What if a skill doesn't work?
-
-**Troubleshooting steps:**
-
-1. **Check installation path**
-   ```bash
-   ls .agent/skills/
-   ```
-
-2. **Verify skill exists**
-   ```bash
-   ls .agent/skills/skill-name/
-   ```
-
-3. **Check SKILL.md exists**
-   ```bash
-   cat .agent/skills/skill-name/SKILL.md
-   ```
-
-4. **Try restarting your AI assistant**
-
-5. **Check for typos in skill name**
-   - Use `@brainstorming` not `@brain-storming`
-   - Names are case-sensitive in some tools
-
-6. **Report the issue**
-   [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues) with details
-
----
-
-## 🤝 Contributing
-
-### I'm new to open source. Can I still contribute?
-
-**Absolutely!** Everyone starts somewhere. We welcome contributions from beginners:
-
-- Fix typos or grammar
-- Improve documentation clarity
-- Add examples to existing skills
-- Report issues or confusing parts
-
-Check out [CONTRIBUTING.md](CONTRIBUTING.md) for step-by-step instructions.
-
----
-
-### Do I need to know how to code to contribute?
-
-**No!** Many valuable contributions don't require coding:
-
-- **Documentation improvements** - Make things clearer
-- **Examples** - Add real-world usage examples
-- **Issue reporting** - Tell us what's confusing
-- **Testing** - Try skills and report what works
-
----
-
-### How do I create a new skill?
-
-**Quick version:**
-
-1. Create a folder: `skills/my-skill-name/`
-2. Create `SKILL.md` with frontmatter and content
-3. Test it with your AI assistant
-4. Run validation: `python3 scripts/validate_skills.py`
-5. Submit a Pull Request
-
-**Detailed version:** See [CONTRIBUTING.md](CONTRIBUTING.md)
-
----
-
-### What makes a good skill?
-
-A good skill:
-- ✅ Solves a specific problem
-- ✅ Has clear, actionable instructions
-- ✅ Includes examples
-- ✅ Is reusable across projects
-- ✅ Follows the standard structure
-
-See [SKILL_ANATOMY.md](docs/SKILL_ANATOMY.md) for details.
-
----
-
-### How long does it take for my contribution to be reviewed?
-
-Review times vary, but typically:
-- **Simple fixes** (typos, docs): 1-3 days
-- **New skills**: 3-7 days
-- **Major changes**: 1-2 weeks
-
-You can speed this up by:
-- Following the contribution guidelines
-- Writing clear commit messages
-- Testing your changes
-- Responding to feedback quickly
-
----
-
-## Technical Questions
-
-### What's the difference between SKILL.md and README.md?
-
-- **SKILL.md** (required): The actual skill definition that the AI reads
-- **README.md** (optional): Human-readable documentation about the skill
-
-The AI primarily uses `SKILL.md`, while developers read `README.md`.
-
----
-
-### Can I use scripts or code in my skill?
-
-**Yes!** Skills can include:
-- `scripts/` - Helper scripts
-- `examples/` - Example code
-- `templates/` - Code templates
-- `references/` - Documentation
-
-Reference them in your `SKILL.md`:
-```markdown
-Run the setup script:
-\`\`\`bash
-bash scripts/setup.sh
-\`\`\`
-```
-
----
-
-### What programming languages can skills cover?
-
-**Any language!** Current skills cover:
-- JavaScript/TypeScript
-- Python
-- Go
-- Rust
-- Swift
-- Kotlin
-- Shell scripting
-- And many more...
-
----
-
-### Can skills call other skills?
-
-**Yes!** Skills can reference other skills:
-
-```markdown
-## Workflow
-
-1. First, use `@brainstorming` to design
-2. Then, use `@writing-plans` to plan
-3. Finally, use `@test-driven-development` to implement
-```
-
----
-
-### How do I validate my skill before submitting?
-
-Run the validation script:
-
-```bash
-python3 scripts/validate_skills.py
-```
-
-This checks:
-- ✅ SKILL.md exists
-- ✅ Frontmatter is valid
-- ✅ Name matches folder name
-- ✅ Description exists
-
----
-
-## Learning & Best Practices
-
-### Which skills should I try first?
-
-**For beginners:**
-- `@brainstorming` - Design before coding
-- `@systematic-debugging` - Fix bugs methodically
-- `@git-pushing` - Commit with good messages
-
-**For developers:**
-- `@test-driven-development` - Write tests first
-- `@react-best-practices` - Modern React patterns
-- `@senior-fullstack` - Full-stack development
-
-**For security:**
-- `@ethical-hacking-methodology` - Security basics
-- `@burp-suite-testing` - Web app testing
-
----
-
-### How do I learn to write good skills?
-
-**Learning path:**
-
-1. **Read existing skills** - Study 5-10 well-written skills
-2. **Use skills** - Try them with your AI assistant
-3. **Read guides** - Check [SKILL_ANATOMY.md](docs/SKILL_ANATOMY.md)
-4. **Start simple** - Create a basic skill first
-5. **Get feedback** - Submit and learn from reviews
-6. **Iterate** - Improve based on feedback
-
-**Recommended skills to study:**
-- `skills/brainstorming/SKILL.md` - Clear structure
-- `skills/systematic-debugging/SKILL.md` - Comprehensive
-- `skills/git-pushing/SKILL.md` - Simple and focused
-
----
-
-### Are there any skills for learning AI/ML?
-
-**Yes!** Check out:
-- `@rag-engineer` - RAG systems
-- `@prompt-engineering` - Prompt design
-- `@langgraph` - Multi-agent systems
-- `@ai-agents-architect` - Agent architecture
-- `@llm-app-patterns` - LLM application patterns
-
----
-
-## Troubleshooting
-
-### My AI assistant doesn't recognize skills
-
-**Possible causes:**
-
-1. **Wrong installation path**
-   - Check your tool's documentation for the correct path
-   - Try `.agent/skills/` as the universal path
-
-2. **Skill name typo**
-   - Verify the exact skill name: `ls .agent/skills/`
-   - Use the exact name from the folder
-
-3. **Tool doesn't support skills**
-   - Verify your tool supports the SKILL.md format
-   - Check the [Compatibility](#-compatibility) section
-
-4. **Need to restart**
-   - Restart your AI assistant after installing skills
-
----
-
-### A skill gives incorrect or outdated advice
-
-**Please report it!**
-
-1. [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues)
-2. Include:
-   - Which skill
-   - What's incorrect
-   - What should it say instead
-   - Links to correct documentation
-
-We'll update it quickly!
-
----
-
-### Can I modify skills for my own use?
-
-**Yes!** The MIT License allows you to:
-- ✅ Modify skills for your needs
-- ✅ Create private versions
-- ✅ Customize for your team
-
-**To modify:**
-1. Copy the skill to a new location
-2. Edit the SKILL.md file
-3. Use your modified version
-
-**Consider contributing improvements back!**
-
----
-
-## Statistics & Info
-
-### How many skills are there?
-
-**179 skills** across 10+ categories as of the latest update.
-
----
-
-### How often are skills updated?
-
-- **Bug fixes**: As soon as reported
-- **New skills**: Added regularly by contributors
-- **Updates**: When best practices change
-
-**Stay updated:**
-```bash
-cd .agent/skills
-git pull origin main
-```
-
----
-
-### Who maintains this repository?
-
-This is a community-driven project with contributions from:
-- Original creators
-- Open source contributors
-- AI coding assistant users worldwide
-
-See [Credits & Sources](README.md#credits--sources) for attribution.
-
----
-
-## Still Have Questions?
-
-### Where can I get help?
-
-- **[GitHub Discussions](https://github.com/sickn33/antigravity-awesome-skills/discussions)** - Ask questions
-- **[GitHub Issues](https://github.com/sickn33/antigravity-awesome-skills/issues)** - Report bugs
-- **Documentation** - Read the guides in this repo
-- **Community** - Connect with other users
-
----
-
-### How can I stay updated?
-
-- **Star the repository** on GitHub
-- **Watch the repository** for updates
-- **Subscribe to releases** for notifications
-- **Follow contributors** on social media
-
----
-
-### Can I use these skills commercially?
-
-**Yes!** The MIT License permits commercial use. You can:
-- ✅ Use in commercial projects
-- ✅ Use in client work
-- ✅ Include in paid products
-- ✅ Modify for commercial purposes
-
-**Only requirement:** Keep the license notice.
-
----
-
-## 💡 Pro Tips
-
-- Start with `@brainstorming` before building anything new
-- Use `@systematic-debugging` when stuck on bugs
-- Try `@test-driven-development` for better code quality
-- Explore `@skill-creator` to make your own skills
-- Read skill descriptions to understand when to use them
-
----
-
-**Question not answered?** 
-
-[Open a discussion](https://github.com/sickn33/antigravity-awesome-skills/discussions) and we'll help you out! 🙌

GETTING_STARTED.md

@@ -1,201 +0,0 @@
-# Getting Started with Antigravity Awesome Skills
-
-**New here? This guide will help you understand and use this repository in 5 minutes!**
-
----
-
-## 🤔 What Are "Skills"?
-
-Think of skills as **specialized instruction manuals** for AI coding assistants. 
-
-**Simple analogy:** Just like you might hire different experts (a designer, a security expert, a marketer), these skills let your AI assistant become an expert in specific areas when you need them.
-
----
-
-## 📦 What's Inside This Repository?
-
-This repo contains **179 ready-to-use skills** organized in the `skills/` folder. Each skill is a folder with at least one file: `SKILL.md`
-
-```
-skills/
-├── brainstorming/
-│   └── SKILL.md          ← The skill definition
-├── stripe-integration/
-│   └── SKILL.md
-├── react-best-practices/
-│   └── SKILL.md
-└── ... (176 more skills)
-```
-
----
-
-## How Do Skills Work?
-
-### Step 1: Install Skills
-Copy the skills to your AI tool's directory:
-
-```bash
-# For most AI tools (Claude Code, Gemini CLI, etc.)
-git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
-```
-
-### Step 2: Use a Skill
-In your AI chat, mention the skill:
-
-```
-@brainstorming help me design a todo app
-```
-
-or
-
-```
-/stripe-integration add payment processing to my app
-```
-
-### Step 3: The AI Becomes an Expert
-The AI loads that skill's knowledge and helps you with specialized expertise!
-
----
-
-## Which AI Tools Work With This?
-
-| Tool | Works? | Installation Path |
-|------|--------|-------------------|
-| **Claude Code** | ✅ Yes | `.claude/skills/` or `.agent/skills/` |
-| **Gemini CLI** | ✅ Yes | `.gemini/skills/` or `.agent/skills/` |
-| **Cursor** | ✅ Yes | `.cursor/skills/` |
-| **GitHub Copilot** | ⚠️ Partial | Copy to `.github/copilot/` |
-| **Antigravity IDE** | ✅ Yes | `.agent/skills/` |
-
----
-
-## Skill Categories (Simplified)
-
-### **Creative & Design** (10 skills)
-Make beautiful things: UI design, art, themes, web components
-- Try: `@frontend-design`, `@canvas-design`, `@ui-ux-pro-max`
-
-### **Development** (25 skills)
-Write better code: testing, debugging, React patterns, architecture
-- Try: `@test-driven-development`, `@systematic-debugging`, `@react-best-practices`
-
-### **Security** (50 skills)
-Ethical hacking and penetration testing tools
-- Try: `@ethical-hacking-methodology`, `@burp-suite-testing`
-
-### **AI & Agents** (30 skills)
-Build AI apps: RAG, LangGraph, prompt engineering, voice agents
-- Try: `@rag-engineer`, `@prompt-engineering`, `@langgraph`
-
-### **Documents** (4 skills)
-Work with Word, Excel, PowerPoint, PDF files
-- Try: `@docx-official`, `@xlsx-official`, `@pdf-official`
-
-### **Marketing** (23 skills)
-Grow your product: SEO, copywriting, ads, email campaigns
-- Try: `@copywriting`, `@seo-audit`, `@page-cro`
-
-### **Integrations** (25 skills)
-Connect to services: Stripe, Firebase, Twilio, Discord, Slack
-- Try: `@stripe-integration`, `@firebase`, `@clerk-auth`
-
----
-
-## Your First Skill: A Quick Example
-
-Let's try the **brainstorming** skill:
-
-1. **Open your AI assistant** (Claude Code, Cursor, etc.)
-
-2. **Type this:**
-   ```
-   @brainstorming I want to build a simple weather app
-   ```
-
-3. **What happens:**
-   - The AI loads the brainstorming skill
-   - It asks you questions one at a time
-   - It helps you design the app before coding
-   - It creates a design document for you
-
-4. **Result:** You get a well-thought-out plan instead of jumping straight to code!
-
----
-
-## How to Find the Right Skill
-
-### Method 1: Browse by Category
-Check the [Full Skill Registry](README.md#full-skill-registry-179179) in the main README
-
-### Method 2: Search by Keyword
-Use your file explorer or terminal:
-```bash
-# Find skills related to "testing"
-ls skills/ | grep test
-
-# Find skills related to "auth"
-ls skills/ | grep auth
-```
-
-### Method 3: Look at the Index
-Check `skills_index.json` for a machine-readable list
-
----
-
-## 🤝 Want to Contribute?
-
-Great! Here's how:
-
-### Option 1: Improve Documentation
-- Make READMEs clearer
-- Add more examples
-- Fix typos or confusing parts
-
-### Option 2: Create a New Skill
-See our [CONTRIBUTING.md](CONTRIBUTING.md) for step-by-step instructions
-
-### Option 3: Report Issues
-Found something confusing? [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues)
-
----
-
-## ❓ Common Questions
-
-### Q: Do I need to install all 179 skills?
-**A:** No! Clone the whole repo, and your AI will only load skills when you use them.
-
-### Q: Can I create my own skills?
-**A:** Yes! Check out the `@skill-creator` skill or read [CONTRIBUTING.md](CONTRIBUTING.md)
-
-### Q: What if my AI tool isn't listed?
-**A:** If it supports the `SKILL.md` format, try `.agent/skills/` - it's the universal path.
-
-### Q: Are these skills free?
-**A:** Yes! MIT License. Use them however you want.
-
-### Q: Do skills work offline?
-**A:** The skill files are local, but your AI assistant needs internet to function.
-
----
-
-## Next Steps
-
-1. ✅ Install the skills in your AI tool
-2. ✅ Try 2-3 skills from different categories
-3. ✅ Read [CONTRIBUTING.md](CONTRIBUTING.md) if you want to help
-4. ✅ Star the repo if you find it useful! ⭐
-
----
-
-## 💡 Pro Tips
-
-- **Start with `@brainstorming`** before building anything new
-- **Use `@systematic-debugging`** when you're stuck on a bug
-- **Try `@test-driven-development`** to write better code
-- **Explore `@skill-creator`** to make your own skills
-
----
-
-**Still confused?** Open an issue and we'll help you out! 🙌
-
-**Ready to dive deeper?** Check out the main [README.md](README.md) for the complete skill list.

README.md

@@ -1,6 +1,6 @@
-# 🌌 Antigravity Awesome Skills: 223+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More
+# 🌌 Antigravity Awesome Skills: 560+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More
 
-> **The Ultimate Collection of 223+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode**
+> **The Ultimate Collection of 560+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-Anthropic-purple)](https://claude.ai)
@@ -9,9 +9,9 @@
 [![Cursor](https://img.shields.io/badge/Cursor-AI%20IDE-orange)](https://cursor.sh)
 [![Copilot](https://img.shields.io/badge/GitHub%20Copilot-VSCode-lightblue)](https://github.com/features/copilot)
 [![OpenCode](https://img.shields.io/badge/OpenCode-CLI-gray)](https://github.com/opencode-ai/opencode)
-[![Antigravity](https://img.shields.io/badge/Antigravity-DeepMind-red)](https://github.com/anthropics/antigravity)
+[![Antigravity](https://img.shields.io/badge/Antigravity-DeepMind-red)](https://github.com/sickn33/antigravity-awesome-skills)
 
-**Antigravity Awesome Skills** is a curated, battle-tested library of **223 high-performance agentic skills** designed to work seamlessly across all major AI coding assistants:
+**Antigravity Awesome Skills** is a curated, battle-tested library of **560 high-performance agentic skills** designed to work seamlessly across all major AI coding assistants:
 
 - 🟣 **Claude Code** (Anthropic CLI)
 - 🔵 **Gemini CLI** (Google DeepMind)
@@ -21,65 +21,78 @@
 - 🟠 **Cursor** (AI-native IDE)
 - ⚪ **OpenCode** (Open-source CLI)
 
-This repository provides essential skills to transform your AI assistant into a **full-stack digital agency**, including official capabilities from **Anthropic**, **OpenAI**, **Google**, and **Vercel Labs**.
+This repository provides essential skills to transform your AI assistant into a **full-stack digital agency**, including official capabilities from **Anthropic**, **OpenAI**, **Google**, **Supabase**, and **Vercel Labs**.
 
-## 📍 Table of Contents
+## Table of Contents
 
-- [🚀 New Here? Start Here!](#-new-here-start-here)
-- [🔌 Compatibility](#-compatibility)
-- [Features & Categories](#features--categories)
-- [Full Skill Registry](#full-skill-registry-155155)
-- [Installation](#installation)
-- [How to Contribute](#how-to-contribute)
-- [Credits & Sources](#credits--sources)
-- [License](#license)
+- [🚀 New Here? Start Here!](#new-here-start-here)
+- [🔌 Compatibility & Invocation](#compatibility--invocation)
+- [📦 Features & Categories](#features--categories)
+- [🎁 Curated Collections (Bundles)](#curated-collections)
+- [📚 Browse 560+ Skills](#browse-560-skills)
+- [🛠️ Installation](#installation)
+- [🤝 How to Contribute](#how-to-contribute)
+- [👥 Contributors & Credits](#credits--sources)
+- [⚖️ License](#license)
+- [👥 Repo Contributors](#repo-contributors)
+- [🌟 Star History](#star-history)
 
 ---
 
 ## New Here? Start Here!
 
-**First time using this repository?** We've created beginner-friendly guides to help you get started:
+**Welcome to the V4.0.0 Enterprise Edition.** This isn't just a list of scripts; it's a complete operating system for your AI Agent.
 
-- **[GETTING_STARTED.md](GETTING_STARTED.md)** - Complete beginner's guide (5-minute read)
-- **[CONTRIBUTING.md](CONTRIBUTING.md)** - How to contribute (step-by-step)
-- **[SKILL_ANATOMY.md](docs/SKILL_ANATOMY.md)** - Understanding how skills work
-- **[VISUAL_GUIDE.md](docs/VISUAL_GUIDE.md)** - Visual guide with diagrams
+### 1. 🐣 Context: What is this?
 
-**Quick Start:**
+**Antigravity Awesome Skills** (Release 4.0.0) is a massive upgrade to your AI's capabilities.
 
-```bash
-# 1. Install skills
-git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+AI Agents (like Claude Code, Cursor, or Gemini) are smart, but they lack **specific tools**. They don't know your company's "Deployment Protocol" or the specific syntax for "AWS CloudFormation".
+**Skills** are small markdown files that teach them how to do these specific tasks perfectly, every time.
 
-# 2. Use a skill in your AI assistant
-@brainstorming help me design a todo app
-```
+### 2. ⚡️ Quick Start (The "Bundle" Way)
 
-That's it! Your AI assistant now has 223 specialized skills. 🎉
+Don't install 560+ skills manually. Use our **Starter Packs**:
 
-**Additional Resources:**
+1.  **Clone the repo**:
+    ```bash
+    git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+    ```
+2.  **Pick your persona** (See [docs/BUNDLES.md](docs/BUNDLES.md)):
+    - **Web Dev?** use the `Web Wizard` pack.
+    - **Hacker?** use the `Security Engineer` pack.
+    - **Just curious?** start with `Essentials`.
 
-- 💡 **[Real-World Examples](docs/EXAMPLES.md)** - See skills in action
-- ❓ **[FAQ](FAQ.md)** - Common questions answered
+### 3. 🧠 How to use
+
+Once installed, just ask your agent naturally:
+
+> "Use the **@brainstorming** skill to help me plan a SaaS."
+> "Run **@lint-and-validate** on this file."
+
+👉 **[Read the Full Getting Started Guide](docs/GETTING_STARTED.md)**
 
 ---
 
-## 🔌 Compatibility
+## Compatibility & Invocation
 
-These skills follow the universal **SKILL.md** format and work with any AI coding assistant that supports agentic skills:
+These skills follow the universal **SKILL.md** format and work with any AI coding assistant that supports agentic skills.
 
-| Tool                | Type      | Compatibility | Installation Path                        |
-| ------------------- | --------- | ------------- | ---------------------------------------- |
-| **Claude Code**     | CLI       | ✅ Full       | `.claude/skills/` or `.agent/skills/`    |
-| **Gemini CLI**      | CLI       | ✅ Full       | `.gemini/skills/` or `.agent/skills/`    |
-| **Codex CLI**       | CLI       | ✅ Full       | `.codex/skills/` or `.agent/skills/`     |
-| **Antigravity IDE** | IDE       | ✅ Full       | `.agent/skills/`                         |
-| **Cursor**          | IDE       | ✅ Full       | `.cursor/skills/` or project root        |
-| **GitHub Copilot**  | Extension | ⚠️ Partial    | Copy skill content to `.github/copilot/` |
-| **OpenCode**        | CLI       | ✅ Full       | `.opencode/skills/` or `.agent/skills/`  |
+| Tool            | Type | Invocation Example                | Path              |
+| :-------------- | :--- | :-------------------------------- | :---------------- |
+| **Claude Code** | CLI  | `>> /skill-name help me...`       | `.claude/skills/` |
+| **Gemini CLI**  | CLI  | `(User Prompt) Use skill-name...` | `.gemini/skills/` |
+| **Antigravity** | IDE  | `(Agent Mode) Use skill...`       | `.agent/skills/`  |
+| **Cursor**      | IDE  | `@skill-name (in Chat)`           | `.cursor/skills/` |
+| **Copilot**     | Ext  | `(Paste content manually)`        | N/A               |
 
 > [!TIP]
-> Most tools auto-discover skills in `.agent/skills/`. For maximum compatibility, clone to this directory.
+> **Universal Path**: We recommend cloning to `.agent/skills/`. Most modern tools (Antigravity, recent CLIs) look here by default.
+
+> [!WARNING]
+> **Windows Users**: This repository uses **symlinks** for official skills.
+> You must enable Developer Mode or run Git as Administrator:
+> `git clone -c core.symlinks=true https://github.com/...`
 
 ---
 
@@ -89,251 +102,29 @@ This repository aggregates the best capabilities from across the open-source com
 
 ## Features & Categories
 
-The repository is organized into several key areas of expertise:
+The repository is organized into specialized domains to transform your AI into an expert across the entire software development lifecycle:
 
-| Category                    | Skills Count | Key Skills Included                                                                                                          |
-| :-------------------------- | :----------- | :--------------------------------------------------------------------------------------------------------------------------- |
-| **🛸 Autonomous & Agentic** | **~8**       | Loki Mode (Startup-in-a-box), Subagent Driven Dev, Dispatching Parallel Agents, Planning With Files, Skill Creator/Developer |
-| **🔌 Integrations & APIs**  | **~25**      | Stripe, Firebase, Supabase, Vercel, Clerk Auth, Twilio, Discord Bot, Slack Bot, GraphQL, AWS Serverless                      |
-| **🛡️ Cybersecurity**        | **~50**      | Ethical Hacking, Metasploit, Burp Suite, SQLMap, Active Directory, AWS/Cloud Pentesting, OWASP Top 100, Red Team Tools       |
-| **🎨 Creative & Design**    | **~10**      | UI/UX Pro Max, Frontend Design, Canvas, Algorithmic Art, Theme Factory, D3 Viz, Web Artifacts                                |
-| **🛠️ Development**          | **~25**      | TDD, Systematic Debugging, React Patterns, Backend/Frontend Guidelines, Senior Fullstack, Software Architecture              |
-| **🏗️ Infrastructure & Git** | **~8**       | Linux Shell Scripting, Git Worktrees, Git Pushing, Conventional Commits, File Organization, GitHub Workflow Automation       |
-| **🤖 AI Agents & LLM**      | **~30**      | LangGraph, CrewAI, Langfuse, RAG Engineer, Prompt Engineer, Voice Agents, Browser Automation, Agent Memory Systems           |
-| **🔄 Workflow & Planning**  | **~6**       | Writing Plans, Executing Plans, Concise Planning, Verification Before Completion, Code Review (Requesting/Receiving)         |
-| **📄 Document Processing**  | **~4**       | DOCX (Official), PDF (Official), PPTX (Official), XLSX (Official)                                                            |
-| **🧪 Testing & QA**         | **~4**       | Webapp Testing, Playwright Automation, Test Fixing, Testing Patterns                                                         |
-| **📈 Product & Strategy**   | **~8**       | Product Manager Toolkit, Content Creator, ASO, Doc Co-authoring, Brainstorming, Internal Comms                               |
-| **📣 Marketing & Growth**   | **~23**      | Page CRO, Copywriting, SEO Audit, Paid Ads, Email Sequence, Pricing Strategy, Referral Program, Launch Strategy              |
-| **🚀 Maker Tools**          | **~11**      | Micro-SaaS Launcher, Browser Extension Builder, Telegram Bot, AI Wrapper Product, Viral Generator, 3D Web Experience         |
+| Category | Focus | Example skills |
+| :--- | :--- | :--- |
+| Architecture (52) | System design, ADRs, C4, and scalable patterns | `architecture`, `c4-context`, `senior-architect` |
+| Business (35) | Growth, pricing, CRO, SEO, and go-to-market | `copywriting`, `pricing-strategy`, `seo-audit` |
+| Data & AI (81) | LLM apps, RAG, agents, observability, analytics | `rag-engineer`, `prompt-engineer`, `langgraph` |
+| Development (72) | Language mastery, framework patterns, code quality | `typescript-expert`, `python-patterns`, `react-patterns` |
+| General (95) | Planning, docs, product ops, writing, guidelines | `brainstorming`, `doc-coauthoring`, `writing-plans` |
+| Infrastructure (72) | DevOps, cloud, serverless, deployment, CI/CD | `docker-expert`, `aws-serverless`, `vercel-deployment` |
+| Security (107) | AppSec, pentesting, vuln analysis, compliance | `api-security-best-practices`, `sql-injection-testing`, `vulnerability-scanner` |
+| Testing (21) | TDD, test design, fixes, QA workflows | `test-driven-development`, `testing-patterns`, `test-fixing` |
+| Workflow (17) | Automation, orchestration, jobs, agents | `workflow-automation`, `inngest`, `trigger-dev` |
 
----
+## Curated Collections
 
-## Full Skill Registry (223/223)
+[Check out our Starter Packs in docs/BUNDLES.md](docs/BUNDLES.md) to find the perfect toolkit for your role.
 
-Below is the complete list of available skills. Each skill folder contains a `SKILL.md` that can be imported into Antigravity or Claude Code.
+## Browse 560+ Skills
 
-> [!NOTE] > **Document Skills**: We provide both **community** and **official Anthropic** versions for DOCX, PDF, PPTX, and XLSX. Locally, the official versions are used by default (via symlinks). In the repository, both versions are available for flexibility.
+We have moved the full skill registry to a dedicated catalog to keep this README clean.
 
-| Skill Name                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                              | Path                                     |
-| :-------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------- |
-| **3D Web Experience**                               | Expert in building 3D experiences for the web - Three.js, React Three Fiber, Spline, WebGL.                                                                                                                                                                                                                                                                                                                                                              | `skills/3d-web-experience`               |
-| **A/B Test Setup**                                  | Plan and implement A/B tests with proper experiment design, statistical significance, and test analysis.                                                                                                                                                                                                                                                                                                                                                 | `skills/ab-test-setup`                   |
-| **Active Directory Attacks**                        | This skill should be used when the user asks to "attack Active Directory", "exploit AD", "Kerberoasting", "DCSync", "pass-the-hash", "BloodHound enumeration", "Golden Ticket", "Silver Ticket", "AS-REP roasting", "NTLM relay", or needs guidance on Windows domain penetration testing.                                                                                                                                                               | `skills/active-directory-attacks`        |
-| **Address GitHub Comments**                         | Use when you need to address review or issue comments on an open GitHub Pull Request using the gh CLI.                                                                                                                                                                                                                                                                                                                                                   | `skills/address-github-comments`         |
-| **Agent Evaluation**                                | Testing and benchmarking LLM agents including behavioral testing, capability assessment, reliability metrics.                                                                                                                                                                                                                                                                                                                                            | `skills/agent-evaluation`                |
-| **Agent Manager Skill**                             | Use when you need to manage multiple local CLI agents via tmux sessions (start/stop/monitor/assign) with cron-friendly scheduling.                                                                                                                                                                                                                                                                                                                       | `skills/agent-manager-skill`             |
-| **Agent Memory Systems**                            | Memory architecture for agents: short-term, long-term (vector stores), and cognitive architectures.                                                                                                                                                                                                                                                                                                                                                      | `skills/agent-memory-systems`            |
-| **Agent Tool Builder**                              | Tool design from schema to error handling. JSON Schema best practices, validation, and MCP.                                                                                                                                                                                                                                                                                                                                                              | `skills/agent-tool-builder`              |
-| **AI Agents Architect**                             | Expert in autonomous AI agents. Tool use, memory systems, planning strategies, multi-agent orchestration.                                                                                                                                                                                                                                                                                                                                                | `skills/ai-agents-architect`             |
-| **AI Product**                                      | LLM integration patterns, RAG architecture, prompt engineering, AI UX, and cost optimization.                                                                                                                                                                                                                                                                                                                                                            | `skills/ai-product`                      |
-| **AI Wrapper Product**                              | Building products that wrap AI APIs into focused tools. Prompt engineering, cost management.                                                                                                                                                                                                                                                                                                                                                             | `skills/ai-wrapper-product`              |
-| **Algolia Search**                                  | Algolia search implementation, indexing strategies, React InstantSearch, relevance tuning.                                                                                                                                                                                                                                                                                                                                                               | `skills/algolia-search`                  |
-| **Algorithmic Art**                                 | Creating algorithmic art using p5.                                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/algorithmic-art`                 |
-| **Analytics Tracking**                              | Set up analytics tracking with GA4, GTM, and custom event implementations for marketing measurement.                                                                                                                                                                                                                                                                                                                                                     | `skills/analytics-tracking`              |
-| **API Fuzzing for Bug Bounty**                      | This skill should be used when the user asks to "test API security", "fuzz APIs", "find IDOR vulnerabilities", "test REST API", "test GraphQL", "API penetration testing", "bug bounty API testing", or needs guidance on API security assessment techniques.                                                                                                                                                                                            | `skills/api-fuzzing-bug-bounty`          |
-| **API Patterns** | API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning. | `skills/api-patterns` |
-| **App Builder** | Main application building orchestrator. Creates full-stack applications from natural language requests. | `skills/app-builder` |
-| **App Store Optimization**                          | Complete App Store Optimization (ASO) toolkit for researching, optimizing, and tracking mobile app performance on Apple App Store and Google Play Store.                                                                                                                                                                                                                                                                                                 | `skills/app-store-optimization`          |
-| **Architecture** | Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. | `skills/architecture` |
-| **Autonomous Agent Patterns**                       | "Design patterns for building autonomous coding agents.                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/autonomous-agent-patterns`       |
-| **Autonomous Agents**                               | AI systems that independently decompose goals, plan actions, execute tools. ReAct, reflection.                                                                                                                                                                                                                                                                                                                                                           | `skills/autonomous-agents`               |
-| **AWS Penetration Testing**                         | This skill should be used when the user asks to "pentest AWS", "test AWS security", "enumerate IAM", "exploit cloud infrastructure", "AWS privilege escalation", "S3 bucket testing", "metadata SSRF", "Lambda exploitation", or needs guidance on Amazon Web Services security assessment.                                                                                                                                                              | `skills/aws-penetration-testing`         |
-| **AWS Serverless**                                  | Serverless on AWS. Lambda, API Gateway, DynamoDB, SQS/SNS, SAM/CDK deployment.                                                                                                                                                                                                                                                                                                                                                                           | `skills/aws-serverless`                  |
-| **Azure Functions**                                 | Azure Functions patterns. Isolated worker model, Durable Functions, cold start optimization.                                                                                                                                                                                                                                                                                                                                                             | `skills/azure-functions`                 |
-| **Backend Guidelines**                              | Comprehensive backend development guide for Node.                                                                                                                                                                                                                                                                                                                                                                                                        | `skills/backend-dev-guidelines`          |
-| **Bash Linux** | Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. | `skills/bash-linux` |
-| **Behavioral Modes** | AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). | `skills/behavioral-modes` |
-| **BlockRun**                                        | Agent wallet for LLM micropayments. Use when user needs capabilities Claude lacks (image generation, real-time X/Twitter data) or explicitly requests external models ("blockrun", "use grok", "use gpt", "dall-e", "deepseek").                                                                                                                                                                                                                         | `skills/blockrun`                        |
-| **Brainstorming**                                   | "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior.                                                                                                                                                                                                                                                                                                                       | `skills/brainstorming`                   |
-| **Brand Guidelines (Anthropic)**                    | Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel.                                                                                                                                                                                                                                                                                                                 | `skills/brand-guidelines-anthropic`      |
-| **Brand Guidelines (Community)**                    | Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel.                                                                                                                                                                                                                                                                                                                 | `skills/brand-guidelines-community`      |
-| **Broken Authentication Testing**                   | This skill should be used when the user asks to "test for broken authentication vulnerabilities", "assess session management security", "perform credential stuffing tests", "evaluate password policies", "test for session fixation", or "identify authentication bypass flaws".                                                                                                                                                                       | `skills/broken-authentication`           |
-| **Browser Automation**                              | Browser automation with Playwright and Puppeteer. Testing, scraping, agentic control.                                                                                                                                                                                                                                                                                                                                                                    | `skills/browser-automation`              |
-| **Browser Extension Builder**                       | Building browser extensions - Chrome, Firefox. Manifest v3, content scripts, monetization.                                                                                                                                                                                                                                                                                                                                                               | `skills/browser-extension-builder`       |
-| **BullMQ Specialist**                               | BullMQ for Redis-backed job queues, background processing in Node.js/TypeScript.                                                                                                                                                                                                                                                                                                                                                                         | `skills/bullmq-specialist`               |
-| **Bun Development**                                 | "Modern JavaScript/TypeScript development with Bun runtime.                                                                                                                                                                                                                                                                                                                                                                                              | `skills/bun-development`                 |
-| **Burp Suite Web Application Testing**              | This skill should be used when the user asks to "intercept HTTP traffic", "modify web requests", "use Burp Suite for testing", "perform web vulnerability scanning", "test with Burp Repeater", "analyze HTTP history", or "configure proxy for web testing".                                                                                                                                                                                            | `skills/burp-suite-testing`              |
-| **Canvas Design**                                   | Create beautiful visual art in .                                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/canvas-design`                   |
-| **Claude Code Guide**                               | Master guide for using Claude Code effectively.                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/claude-code-guide`               |
-| **Claude D3.js**                                    | Creating interactive data visualisations using d3.                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/claude-d3js-skill`               |
-| **Clean Code** | Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments. | `skills/clean-code` |
-| **Clerk Auth**                                      | Clerk auth implementation, middleware, organizations, webhooks, user sync.                                                                                                                                                                                                                                                                                                                                                                               | `skills/clerk-auth`                      |
-| **Cloud Penetration Testing**                       | This skill should be used when the user asks to "perform cloud penetration testing", "assess Azure or AWS or GCP security", "enumerate cloud resources", "exploit cloud misconfigurations", "test O365 security", "extract secrets from cloud environments", or "audit cloud infrastructure".                                                                                                                                                            | `skills/cloud-penetration-testing`       |
-| **Code Review Checklist** | Code review guidelines covering code quality, security, and best practices. | `skills/code-review-checklist` |
-| **Competitor Alternatives**                         | Create compelling competitor comparison and alternative pages for SEO and conversions.                                                                                                                                                                                                                                                                                                                                                                   | `skills/competitor-alternatives`         |
-| **Computer Use Agents**                             | AI agents that interact with computers like humans. Screen control, sandboxing.                                                                                                                                                                                                                                                                                                                                                                          | `skills/computer-use-agents`             |
-| **Concise Planning**                                | Use when a user asks for a plan for a coding task, to generate a clear, actionable, and atomic checklist.                                                                                                                                                                                                                                                                                                                                                | `skills/concise-planning`                |
-| **Content Creator**                                 | Create SEO-optimized marketing content with consistent brand voice.                                                                                                                                                                                                                                                                                                                                                                                      | `skills/content-creator`                 |
-| **Context Window Management**                       | Managing LLM context windows. Summarization, trimming, routing.                                                                                                                                                                                                                                                                                                                                                                                          | `skills/context-window-management`       |
-| **Conversation Memory**                             | Persistent memory for LLM conversations. Short-term, long-term, entity-based memory.                                                                                                                                                                                                                                                                                                                                                                     | `skills/conversation-memory`             |
-| **Copy Editing**                                    | Edit and polish existing marketing copy with a systematic seven-sweeps framework.                                                                                                                                                                                                                                                                                                                                                                        | `skills/copy-editing`                    |
-| **Copywriting**                                     | Write compelling marketing copy for homepages, landing pages, pricing pages, and feature pages.                                                                                                                                                                                                                                                                                                                                                          | `skills/copywriting`                     |
-| **Core Components**                                 | Core component library and design system patterns.                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/core-components`                 |
-| **CrewAI**                                          | Role-based multi-agent framework. Agent design, task definition, crew orchestration.                                                                                                                                                                                                                                                                                                                                                                     | `skills/crewai`                          |
-| **Cross-Site Scripting and HTML Injection Testing** | This skill should be used when the user asks to "test for XSS vulnerabilities", "perform cross-site scripting attacks", "identify HTML injection flaws", "exploit client-side injection vulnerabilities", "steal cookies via XSS", or "bypass content security policies".                                                                                                                                                                                | `skills/xss-html-injection`              |
-| **Database Design** | Database design principles. Schema design, indexing strategy, ORM selection, serverless databases. | `skills/database-design` |
-| **Deployment Procedures** | Production deployment principles. Safe deployment workflows, rollback strategies, and verification. | `skills/deployment-procedures` |
-| **Discord Bot Architect**                           | Production Discord bots. Discord.js, Pycord, slash commands, sharding.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/discord-bot-architect`           |
-| **Dispatching Parallel Agents**                     | Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies.                                                                                                                                                                                                                                                                                                                                              | `skills/dispatching-parallel-agents`     |
-| **Doc Co-authoring**                                | Guide users through a structured workflow for co-authoring documentation.                                                                                                                                                                                                                                                                                                                                                                                | `skills/doc-coauthoring`                 |
-| **Docker Expert** | Docker containerization expert. Multi-stage builds, image optimization, container security, Docker Compose. | `skills/docker-expert` |
-| **Documentation Templates** | Documentation templates and structure guidelines. README, API docs, code comments. | `skills/documentation-templates` |
-| **DOCX (Official)**                                 | "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction.                                                                                                                                                                                                                                                                                                        | `skills/docx-official`                   |
-| **Email Sequence**                                  | Create and optimize email sequences, drip campaigns, and lifecycle email programs.                                                                                                                                                                                                                                                                                                                                                                       | `skills/email-sequence`                  |
-| **Email Systems**                                   | Transactional email, marketing automation, deliverability, infrastructure.                                                                                                                                                                                                                                                                                                                                                                               | `skills/email-systems`                   |
-| **Ethical Hacking Methodology**                     | This skill should be used when the user asks to "learn ethical hacking", "understand penetration testing lifecycle", "perform reconnaissance", "conduct security scanning", "exploit vulnerabilities", or "write penetration test reports".                                                                                                                                                                                                              | `skills/ethical-hacking-methodology`     |
-| **Executing Plans**                                 | Use when you have a written implementation plan to execute in a separate session with review checkpoints.                                                                                                                                                                                                                                                                                                                                                | `skills/executing-plans`                 |
-| **File Organizer**                                  | Intelligently organizes files and folders by understanding context, finding duplicates, and suggesting better organizational structures.                                                                                                                                                                                                                                                                                                                 | `skills/file-organizer`                  |
-| **File Path Traversal Testing**                     | This skill should be used when the user asks to "test for directory traversal", "exploit path traversal vulnerabilities", "read arbitrary files through web applications", "find LFI vulnerabilities", or "access files outside web root".                                                                                                                                                                                                               | `skills/file-path-traversal`             |
-| **File Uploads**                                    | File uploads and cloud storage. S3, Cloudflare R2, presigned URLs.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/file-uploads`                    |
-| **Finishing Dev Branch**                            | Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup.                                                                                                                                                                                                                                                | `skills/finishing-a-development-branch`  |
-| **Firebase**                                        | Firebase Auth, Firestore, Realtime Database, Cloud Functions, Storage.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/firebase`                        |
-| **Form CRO**                                        | Optimize lead capture forms, contact forms, demo request forms for higher conversion rates.                                                                                                                                                                                                                                                                                                                                                              | `skills/form-cro`                        |
-| **Free Tool Strategy**                              | Plan and build free tools for marketing, lead generation, and SEO value.                                                                                                                                                                                                                                                                                                                                                                                 | `skills/free-tool-strategy`              |
-| **Frontend Design**                                 | Create distinctive, production-grade frontend interfaces with high design quality.                                                                                                                                                                                                                                                                                                                                                                       | `skills/frontend-design`                 |
-| **Frontend Guidelines**                             | Frontend development guidelines for React/TypeScript applications.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/frontend-dev-guidelines`         |
-| **Game Development** | Game development orchestrator. Routes to platform-specific skills based on project needs. | `skills/game-development` |
-| **GCP Cloud Run**                                   | Serverless on GCP. Cloud Run services and functions, Pub/Sub.                                                                                                                                                                                                                                                                                                                                                                                            | `skills/gcp-cloud-run`                   |
-| **GEO Fundamentals** | Generative Engine Optimization for AI search engines (ChatGPT, Claude, Perplexity). | `skills/geo-fundamentals` |
-| **Git Pushing**                                     | Stage, commit, and push git changes with conventional commit messages.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/git-pushing`                     |
-| **GitHub Workflow Automation**                      | "Automate GitHub workflows with AI assistance.                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/github-workflow-automation`      |
-| **GraphQL**                                         | Schema design, resolvers, DataLoader, federation, Apollo/urql integration.                                                                                                                                                                                                                                                                                                                                                                               | `skills/graphql`                         |
-| **HTML Injection Testing**                          | This skill should be used when the user asks to "test for HTML injection", "inject HTML into web pages", "perform HTML injection attacks", "deface web applications", or "test content injection vulnerabilities".                                                                                                                                                                                                                                       | `skills/html-injection-testing`          |
-| **HubSpot Integration**                             | HubSpot CRM integration. OAuth, CRM objects, webhooks, custom objects.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/hubspot-integration`             |
-| **i18n Localization** | Internationalization and localization patterns. Detecting hardcoded strings, managing translations. | `skills/i18n-localization` |
-| **IDOR Vulnerability Testing**                      | This skill should be used when the user asks to "test for insecure direct object references," "find IDOR vulnerabilities," "exploit broken access control," "enumerate user IDs or object references," or "bypass authorization to access other users' data.                                                                                                                                                                                             | `skills/idor-testing`                    |
-| **Inngest**                                         | Inngest for serverless background jobs, event-driven workflows.                                                                                                                                                                                                                                                                                                                                                                                          | `skills/inngest`                         |
-| **Interactive Portfolio**                           | Building portfolios that land jobs. Developer, designer portfolios.                                                                                                                                                                                                                                                                                                                                                                                      | `skills/interactive-portfolio`           |
-| **Internal Comms (Anthropic)**                      | A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use.                                                                                                                                                                                                                                                                                                                                | `skills/internal-comms-anthropic`        |
-| **Internal Comms (Community)**                      | A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use.                                                                                                                                                                                                                                                                                                                                | `skills/internal-comms-community`        |
-| **JavaScript Mastery**                              | "Comprehensive JavaScript reference covering 33+ essential concepts every developer should know.                                                                                                                                                                                                                                                                                                                                                         | `skills/javascript-mastery`              |
-| **Kaizen**                                          | Guide for continuous improvement, error proofing, and standardization.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/kaizen`                          |
-| **Langfuse**                                        | Open-source LLM observability. Tracing, prompt management, evaluation.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/langfuse`                        |
-| **LangGraph**                                       | Stateful, multi-actor AI applications. Graph construction, persistence.                                                                                                                                                                                                                                                                                                                                                                                  | `skills/langgraph`                       |
-| **Launch Strategy**                                 | Plan product launches, feature announcements, and go-to-market strategies.                                                                                                                                                                                                                                                                                                                                                                               | `skills/launch-strategy`                 |
-| **Lint and Validate** | Automatic quality control, linting, and static analysis procedures. | `skills/lint-and-validate` |
-| **Linux Privilege Escalation**                      | This skill should be used when the user asks to "escalate privileges on Linux", "find privesc vectors on Linux systems", "exploit sudo misconfigurations", "abuse SUID binaries", "exploit cron jobs for root access", "enumerate Linux systems for privilege escalation", or "gain root access from low-privilege shell".                                                                                                                               | `skills/linux-privilege-escalation`      |
-| **Linux Shell Scripting**                           | This skill should be used when the user asks to "create bash scripts", "automate Linux tasks", "monitor system resources", "backup files", "manage users", or "write production shell scripts".                                                                                                                                                                                                                                                          | `skills/linux-shell-scripting`           |
-| **LLM App Patterns**                                | "Production-ready patterns for building LLM applications.                                                                                                                                                                                                                                                                                                                                                                                                | `skills/llm-app-patterns`                |
-| **Loki Mode**                                       | Multi-agent autonomous startup system for Claude Code.                                                                                                                                                                                                                                                                                                                                                                                                   | `skills/loki-mode`                       |
-| **Marketing Ideas**                                 | 140 proven SaaS marketing ideas and strategies organized by category.                                                                                                                                                                                                                                                                                                                                                                                    | `skills/marketing-ideas`                 |
-| **Marketing Psychology**                            | 70+ mental models and psychological principles for marketing and persuasion.                                                                                                                                                                                                                                                                                                                                                                             | `skills/marketing-psychology`            |
-| **MCP Builder**                                     | Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools.                                                                                                                                                                                                                                                                                                    | `skills/mcp-builder`                     |
-| **Metasploit Framework**                            | This skill should be used when the user asks to "use Metasploit for penetration testing", "exploit vulnerabilities with msfconsole", "create payloads with msfvenom", "perform post-exploitation", "use auxiliary modules for scanning", or "develop custom exploits".                                                                                                                                                                                   | `skills/metasploit-framework`            |
-| **Micro-SaaS Launcher**                             | Launching small SaaS products fast. Idea validation, MVP, pricing.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/micro-saas-launcher`             |
-| **Mobile Design** | Mobile-first design thinking for iOS and Android apps. Touch interaction, performance patterns. | `skills/mobile-design` |
-| **Moodle External API Development**                 | Create custom external web service APIs for Moodle LMS. Use when implementing web services for course management, user tracking, quiz operations, or custom plugin functionality. Covers parameter validation, database operations, error handling, service registration, and Moodle coding standards.                                                                                                                                                   | `skills/moodle-external-api-development` |
-| **Neon Postgres**                                   | Neon serverless Postgres, branching, connection pooling, Prisma integration.                                                                                                                                                                                                                                                                                                                                                                             | `skills/neon-postgres`                   |
-| **NestJS Expert** | Nest.js framework expert. Module architecture, dependency injection, middleware, guards, interceptors. | `skills/nestjs-expert` |
-| **Network 101**                                     | This skill should be used when the user asks to "set up a web server", "configure HTTP or HTTPS", "perform SNMP enumeration", "configure SMB shares", "test network services", or needs guidance on configuring and testing network services for penetration testing labs.                                                                                                                                                                               | `skills/network-101`                     |
-| **Next.js Best Practices** | Next.js App Router principles. Server Components, data fetching, routing patterns. | `skills/nextjs-best-practices` |
-| **Next.js Supabase Auth**                           | Supabase Auth with Next.js App Router. Auth middleware.                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/nextjs-supabase-auth`            |
-| **Node.js Best Practices** | Node.js development principles. Framework selection, async patterns, security, architecture. | `skills/nodejs-best-practices` |
-| **NotebookLM**                                      | Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini.                                                                                                                                                                                                                                                                                                             | `skills/notebooklm`                      |
-| **Notion Template Business**                        | Building and selling Notion templates. Design, pricing, marketing.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/notion-template-business`        |
-| **Onboarding CRO**                                  | Optimize post-signup onboarding, user activation, and time-to-value.                                                                                                                                                                                                                                                                                                                                                                                     | `skills/onboarding-cro`                  |
-| **Page CRO**                                        | Conversion rate optimization for marketing pages - homepages, landing pages, pricing pages.                                                                                                                                                                                                                                                                                                                                                              | `skills/page-cro`                        |
-| **Paid Ads**                                        | Create and optimize paid ad campaigns on Google Ads, Meta, LinkedIn, and other platforms.                                                                                                                                                                                                                                                                                                                                                                | `skills/paid-ads`                        |
-| **Parallel Agents** | Multi-agent orchestration patterns. Use when multiple independent tasks can run with different domain expertise. | `skills/parallel-agents` |
-| **Paywall Upgrade CRO**                             | Optimize in-app paywalls, upgrade screens, and freemium conversion moments.                                                                                                                                                                                                                                                                                                                                                                              | `skills/paywall-upgrade-cro`             |
-| **PDF (Official)**                                  | Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms.                                                                                                                                                                                                                                                                                                               | `skills/pdf-official`                    |
-| **Pentest Checklist**                               | This skill should be used when the user asks to "plan a penetration test", "create a security assessment checklist", "prepare for penetration testing", "define pentest scope", "follow security testing best practices", or needs a structured methodology for penetration testing engagements.                                                                                                                                                         | `skills/pentest-checklist`               |
-| **Pentest Commands**                                | This skill should be used when the user asks to "run pentest commands", "scan with nmap", "use metasploit exploits", "crack passwords with hydra or john", "scan web vulnerabilities with nikto", "enumerate networks", or needs essential penetration testing command references.                                                                                                                                                                       | `skills/pentest-commands`                |
-| **Performance Profiling** | Performance profiling principles. Measurement, analysis, and optimization techniques. | `skills/performance-profiling` |
-| **Personal Tool Builder**                           | Building custom tools. Rapid prototyping, local-first apps, CLI tools.                                                                                                                                                                                                                                                                                                                                                                                   | `skills/personal-tool-builder`           |
-| **Plaid Fintech**                                   | Plaid API for banking. Link token flows, transactions, ACH.                                                                                                                                                                                                                                                                                                                                                                                              | `skills/plaid-fintech`                   |
-| **Plan Writing** | Structured task planning with clear breakdowns, dependencies, and verification criteria. | `skills/plan-writing` |
-| **Planning With Files**                             | Implements Manus-style file-based planning for complex tasks.                                                                                                                                                                                                                                                                                                                                                                                            | `skills/planning-with-files`             |
-| **Playwright Automation**                           | Complete browser automation with Playwright.                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/playwright-skill`                |
-| **Popup CRO**                                       | Create and optimize popups, modals, and overlays for conversion.                                                                                                                                                                                                                                                                                                                                                                                         | `skills/popup-cro`                       |
-| **PowerShell Windows** | PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling. | `skills/powershell-windows` |
-| **PPTX (Official)**                                 | "Presentation creation, editing, and analysis.                                                                                                                                                                                                                                                                                                                                                                                                           | `skills/pptx-official`                   |
-| **Pricing Strategy**                                | Design pricing, packaging, and monetization strategy for SaaS products.                                                                                                                                                                                                                                                                                                                                                                                  | `skills/pricing-strategy`                |
-| **Prisma Expert** | Prisma ORM expert for schema design, migrations, query optimization, relations modeling. | `skills/prisma-expert` |
-| **Privilege Escalation Methods**                    | This skill should be used when the user asks to "escalate privileges", "get root access", "become administrator", "privesc techniques", "abuse sudo", "exploit SUID binaries", "Kerberoasting", "pass-the-ticket", "token impersonation", or needs guidance on post-exploitation privilege escalation for Linux or Windows systems.                                                                                                                      | `skills/privilege-escalation-methods`    |
-| **Product Toolkit**                                 | Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies.                                                                                                                                                                                                                                                                                 | `skills/product-manager-toolkit`         |
-| **Programmatic SEO**                                | Build SEO-driven pages at scale using templates and data.                                                                                                                                                                                                                                                                                                                                                                                                | `skills/programmatic-seo`                |
-| **Prompt Caching**                                  | Caching strategies for LLM prompts. Anthropic caching, CAG.                                                                                                                                                                                                                                                                                                                                                                                              | `skills/prompt-caching`                  |
-| **Prompt Engineer**                                 | Designing prompts for LLM applications. Structure, evaluation.                                                                                                                                                                                                                                                                                                                                                                                           | `skills/prompt-engineer`                 |
-| **Prompt Engineering**                              | Expert guide on prompt engineering patterns, best practices, and optimization techniques.                                                                                                                                                                                                                                                                                                                                                                | `skills/prompt-engineering`              |
-| **Prompt Library**                                  | "Curated collection of high-quality prompts for various use cases.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/prompt-library`                  |
-| **Python Patterns** | Python development principles. Framework selection, async patterns, type hints, project structure. | `skills/python-patterns` |
-| **RAG Engineer**                                    | Building RAG systems. Embedding models, vector databases, chunking.                                                                                                                                                                                                                                                                                                                                                                                      | `skills/rag-engineer`                    |
-| **RAG Implementation**                              | RAG patterns. Chunking, embeddings, vector stores.                                                                                                                                                                                                                                                                                                                                                                                                       | `skills/rag-implementation`              |
-| **React Best Practices**                            | React and Next.                                                                                                                                                                                                                                                                                                                                                                                                                                          | `skills/react-best-practices`            |
-| **React Patterns** | Modern React patterns and principles. Hooks, composition, performance, TypeScript best practices. | `skills/react-patterns` |
-| **React UI Patterns**                               | Modern React UI patterns for loading states, error handling, and data fetching.                                                                                                                                                                                                                                                                                                                                                                          | `skills/react-ui-patterns`               |
-| **Receiving Code Review**                           | Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation.                                                                                                                                                                                                              | `skills/receiving-code-review`           |
-| **Red Team Tactics** | Red team tactics principles based on MITRE ATT&CK. Attack phases, detection evasion, reporting. | `skills/red-team-tactics` |
-| **Red Team Tools and Methodology**                  | This skill should be used when the user asks to "follow red team methodology", "perform bug bounty hunting", "automate reconnaissance", "hunt for XSS vulnerabilities", "enumerate subdomains", or needs security researcher techniques and tool configurations from top bug bounty hunters.                                                                                                                                                             | `skills/red-team-tools`                  |
-| **Referral Program**                                | Design referral programs, affiliate programs, and word-of-mouth strategies.                                                                                                                                                                                                                                                                                                                                                                              | `skills/referral-program`                |
-| **Requesting Code Review**                          | Use when completing tasks, implementing major features, or before merging to verify work meets requirements.                                                                                                                                                                                                                                                                                                                                             | `skills/requesting-code-review`          |
-| **Salesforce Development**                          | Salesforce integration, Apex development, Lightning components.                                                                                                                                                                                                                                                                                                                                                                                          | `skills/salesforce-development`          |
-| **Schema Markup**                                   | Add structured data and JSON-LD schema markup for SEO and rich snippets.                                                                                                                                                                                                                                                                                                                                                                                 | `skills/schema-markup`                   |
-| **Scroll Experience**                               | GSAP/Framer scroll-driven storytelling. Parallax effects.                                                                                                                                                                                                                                                                                                                                                                                                | `skills/scroll-experience`               |
-| **Security Scanning Tools**                         | This skill should be used when the user asks to "perform vulnerability scanning", "scan networks for open ports", "assess web application security", "scan wireless networks", "detect malware", "check cloud security", or "evaluate system compliance".                                                                                                                                                                                                | `skills/scanning-tools`                  |
-| **Segment CDP**                                     | Segment customer data platform. Event tracking, identity resolution.                                                                                                                                                                                                                                                                                                                                                                                     | `skills/segment-cdp`                     |
-| **Senior Architect**                                | Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin, Flutter, Postgres, GraphQL, Go, Python.                                                                                                                                                                                                                                                      | `skills/senior-architect`                |
-| **Senior Fullstack**                                | Comprehensive fullstack development skill for building complete web applications with React, Next.                                                                                                                                                                                                                                                                                                                                                       | `skills/senior-fullstack`                |
-| **SEO Audit**                                       | Audit technical and on-page SEO issues for better search rankings.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/seo-audit`                       |
-| **SEO Fundamentals** | SEO fundamentals, E-E-A-T, Core Web Vitals, and Google algorithm principles. | `skills/seo-fundamentals` |
-| **Server Management** | Server management principles. Process management, monitoring strategy, and scaling decisions. | `skills/server-management` |
-| **Shodan Reconnaissance and Pentesting**            | This skill should be used when the user asks to "search for exposed devices on the internet," "perform Shodan reconnaissance," "find vulnerable services using Shodan," "scan IP ranges with Shodan," or "discover IoT devices and open ports.                                                                                                                                                                                                           | `skills/shodan-reconnaissance`           |
-| **Shopify Apps**                                    | Building Shopify apps. App Bridge, Polaris, webhooks.                                                                                                                                                                                                                                                                                                                                                                                                    | `skills/shopify-apps`                    |
-| **Shopify Development**                             | Build Shopify apps, extensions, themes using GraphQL Admin API, Shopify CLI, Polaris UI, and Liquid. Use when user asks about "shopify app", "checkout extension", "shopify theme", "liquid template", "polaris", "shopify graphql", "shopify webhook", or "metafields".                                                                                                                                                                                 | `skills/shopify-development`             |
-| **Signup Flow CRO**                                 | Optimize signup, registration, and trial activation flows for higher conversions.                                                                                                                                                                                                                                                                                                                                                                        | `skills/signup-flow-cro`                 |
-| **Skill Creator**                                   | Guide for creating effective skills.                                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/skill-creator`                   |
-| **Skill Developer**                                 | Create and manage Claude Code skills following Anthropic best practices.                                                                                                                                                                                                                                                                                                                                                                                 | `skills/skill-developer`                 |
-| **Slack Bot Builder**                               | Production Slack bots. Bolt framework, slash commands, modals.                                                                                                                                                                                                                                                                                                                                                                                           | `skills/slack-bot-builder`               |
-| **Slack GIF Creator**                               | Knowledge and utilities for creating animated GIFs optimized for Slack.                                                                                                                                                                                                                                                                                                                                                                                  | `skills/slack-gif-creator`               |
-| **SMTP Penetration Testing**                        | This skill should be used when the user asks to "perform SMTP penetration testing", "enumerate email users", "test for open mail relays", "grab SMTP banners", "brute force email credentials", or "assess mail server security".                                                                                                                                                                                                                        | `skills/smtp-penetration-testing`        |
-| **Social Content**                                  | Create and schedule social media content for LinkedIn, Twitter/X, and other platforms.                                                                                                                                                                                                                                                                                                                                                                   | `skills/social-content`                  |
-| **Software Architecture**                           | Guide for quality focused software architecture.                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/software-architecture`           |
-| **SQL Injection Testing**                           | This skill should be used when the user asks to "test for SQL injection vulnerabilities", "perform SQLi attacks", "bypass authentication using SQL injection", "extract database information through injection", "detect SQL injection flaws", or "exploit database query vulnerabilities".                                                                                                                                                              | `skills/sql-injection-testing`           |
-| **SQLMap Database Penetration Testing**             | This skill should be used when the user asks to "automate SQL injection testing," "enumerate database structure," "extract database credentials using sqlmap," "dump tables and columns from a vulnerable database," or "perform automated database penetration testing.                                                                                                                                                                                 | `skills/sqlmap-database-pentesting`      |
-| **SSH Penetration Testing**                         | This skill should be used when the user asks to "pentest SSH services", "enumerate SSH configurations", "brute force SSH credentials", "exploit SSH vulnerabilities", "perform SSH tunneling", or "audit SSH security".                                                                                                                                                                                                                                  | `skills/ssh-penetration-testing`         |
-| **Stripe Integration**                              | Stripe patterns. Checkout, subscriptions, payment intents, webhooks.                                                                                                                                                                                                                                                                                                                                                                                     | `skills/stripe-integration`              |
-| **Subagent Driven Dev**                             | Use when executing implementation plans with independent tasks in the current session.                                                                                                                                                                                                                                                                                                                                                                   | `skills/subagent-driven-development`     |
-| **Systematic Debugging**                            | Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes.                                                                                                                                                                                                                                                                                                                                                             | `skills/systematic-debugging`            |
-| **Tailwind Patterns** | Tailwind CSS v4 principles. CSS-first configuration, container queries, design token architecture. | `skills/tailwind-patterns` |
-| **TDD**                                             | Use when implementing any feature or bugfix, before writing implementation code.                                                                                                                                                                                                                                                                                                                                                                         | `skills/test-driven-development`         |
-| **TDD Workflow** | Test-Driven Development workflow principles. RED-GREEN-REFACTOR cycle. | `skills/tdd-workflow` |
-| **Telegram Bot Builder**                            | Building Telegram bots. Bot API, inline mode, payments, Mini Apps.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/telegram-bot-builder`            |
-| **Telegram Mini App**                               | TON Connect, Telegram Mini Apps, wallet integration.                                                                                                                                                                                                                                                                                                                                                                                                     | `skills/telegram-mini-app`               |
-| **Test Fixing**                                     | Run tests and systematically fix all failing tests using smart error grouping.                                                                                                                                                                                                                                                                                                                                                                           | `skills/test-fixing`                     |
-| **Testing Patterns**                                | Jest testing patterns, factory functions, mocking strategies, and TDD workflow.                                                                                                                                                                                                                                                                                                                                                                          | `skills/testing-patterns`                |
-| **Theme Factory**                                   | Toolkit for styling artifacts with a theme.                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/theme-factory`                   |
-| **Top 100 Vulnerabilities**                         | This skill should be used when the user asks to "identify web application vulnerabilities", "explain common security flaws", "understand vulnerability categories", "learn about injection attacks", "review access control weaknesses", "analyze API security issues", "assess security misconfigurations", "understand client-side vulnerabilities", "examine mobile and IoT security flaws", or "reference the OWASP-aligned vulnerability taxonomy". | `skills/top-web-vulnerabilities`         |
-| **Trigger.dev**                                     | Trigger.dev for serverless background jobs. Long-running tasks.                                                                                                                                                                                                                                                                                                                                                                                          | `skills/trigger-dev`                     |
-| **Twilio Communications**                           | Twilio for SMS, voice, video. Programmable messaging, OTP.                                                                                                                                                                                                                                                                                                                                                                                               | `skills/twilio-communications`           |
-| **TypeScript Expert** | TypeScript expert with deep knowledge of type-level programming, performance optimization, migration strategies. | `skills/typescript-expert` |
-| **UI/UX Pro Max**                                   | "UI/UX design intelligence.                                                                                                                                                                                                                                                                                                                                                                                                                              | `skills/ui-ux-pro-max`                   |
-| **Upstash QStash**                                  | Upstash QStash for serverless message queues.                                                                                                                                                                                                                                                                                                                                                                                                            | `skills/upstash-qstash`                  |
-| **Using Git Worktrees**                             | Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification.                                                                                                                                                                                                                                             | `skills/using-git-worktrees`             |
-| **Using Superpowers**                               | Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions.                                                                                                                                                                                                                                                                                         | `skills/using-superpowers`               |
-| **Vercel Deployment**                               | Vercel deployment. Edge functions, preview deployments.                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/vercel-deployment`               |
-| **Verification Before Completion**                  | Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always.                                                                                                                                                                                                                       | `skills/verification-before-completion`  |
-| **Viral Generator Builder**                         | Building shareable generators that go viral.                                                                                                                                                                                                                                                                                                                                                                                                             | `skills/viral-generator-builder`         |
-| **Voice Agents**                                    | Voice-based AI assistants. Speech-to-text, real-time conversation.                                                                                                                                                                                                                                                                                                                                                                                       | `skills/voice-agents`                    |
-| **Voice AI Development**                            | Voice AI patterns. Wake words, streaming ASR, emotional TTS.                                                                                                                                                                                                                                                                                                                                                                                             | `skills/voice-ai-development`            |
-| **Vulnerability Scanner** | Advanced vulnerability analysis principles. OWASP 2025, Supply Chain Security, attack surface mapping. | `skills/vulnerability-scanner` |
-| **Web Artifacts**                                   | Suite of tools for creating elaborate, multi-component claude.                                                                                                                                                                                                                                                                                                                                                                                           | `skills/web-artifacts-builder`           |
-| **Web Design Guidelines**                           | Review UI code for Web Interface Guidelines compliance.                                                                                                                                                                                                                                                                                                                                                                                                  | `skills/web-design-guidelines`           |
-| **Webapp Testing**                                  | Toolkit for interacting with and testing local web applications using Playwright.                                                                                                                                                                                                                                                                                                                                                                        | `skills/webapp-testing`                  |
-| **Windows Privilege Escalation**                    | This skill should be used when the user asks to "escalate privileges on Windows," "find Windows privesc vectors," "enumerate Windows for privilege escalation," "exploit Windows misconfigurations," or "perform post-exploitation privilege escalation.                                                                                                                                                                                                 | `skills/windows-privilege-escalation`    |
-| **Wireshark Network Traffic Analysis**              | This skill should be used when the user asks to "analyze network traffic with Wireshark", "capture packets for troubleshooting", "filter PCAP files", "follow TCP/UDP streams", "detect network anomalies", "investigate suspicious traffic", or "perform protocol analysis".                                                                                                                                                                            | `skills/wireshark-analysis`              |
-| **WordPress Penetration Testing**                   | This skill should be used when the user asks to "pentest WordPress sites", "scan WordPress for vulnerabilities", "enumerate WordPress users, themes, or plugins", "exploit WordPress vulnerabilities", or "use WPScan".                                                                                                                                                                                                                                  | `skills/wordpress-penetration-testing`   |
-| **Workflow Automation**                             | "Design and implement automated workflows combining visual logic with custom code.                                                                                                                                                                                                                                                                                                                                                                       | `skills/workflow-automation`             |
-| **Writing Plans**                                   | Use when you have a spec or requirements for a multi-step task, before touching code.                                                                                                                                                                                                                                                                                                                                                                    | `skills/writing-plans`                   |
-| **Writing Skills**                                  | Use when creating new skills, editing existing skills, or verifying skills work before deployment.                                                                                                                                                                                                                                                                                                                                                       | `skills/writing-skills`                  |
-| **XLSX (Official)**                                 | "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization.                                                                                                                                                                                                                                                                                                                      | `skills/xlsx-official`                   |
-| **Zapier/Make Patterns**                            | No-code automation. Zapier, Make, n8n workflows.                                                                                                                                                                                                                                                                                                                                                                                                         | `skills/zapier-make-patterns`            |
-
-> [!TIP]
-> Use the `validate_skills.py` script in the `scripts/` directory to ensure all skills are properly formatted and ready for use.
-
----
+👉 **[View the Complete Skill Catalog (CATALOG.md)](CATALOG.md)**
 
 ## Installation
 
@@ -371,17 +162,32 @@ Please ensure your skill follows the Antigravity/Claude Code best practices.
 
 ## Credits & Sources
 
+We stand on the shoulders of giants.
+
+👉 **[View the Full Attribution Ledger](docs/SOURCES.md)**
+
+Key contributors and sources include:
+
+- **HackTricks**
+- **OWASP**
+- **Anthropic / OpenAI / Google**
+- **The Open Source Community**
+
 This collection would not be possible without the incredible work of the Claude Code community and official sources:
 
 ### Official Sources
 
 - **[anthropics/skills](https://github.com/anthropics/skills)**: Official Anthropic skills repository - Document manipulation (DOCX, PDF, PPTX, XLSX), Brand Guidelines, Internal Communications.
 - **[anthropics/claude-cookbooks](https://github.com/anthropics/claude-cookbooks)**: Official notebooks and recipes for building with Claude.
+- **[remotion-dev/skills](https://github.com/remotion-dev/skills)**: Official Remotion skills - Video creation in React with 28 modular rules.
 - **[vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills)**: Vercel Labs official skills - React Best Practices, Web Design Guidelines.
 - **[openai/skills](https://github.com/openai/skills)**: OpenAI Codex skills catalog - Agent skills, Skill Creator, Concise Planning.
+- **[supabase/agent-skills](https://github.com/supabase/agent-skills)**: Supabase official skills - Postgres Best Practices.
 
 ### Community Contributors
 
+- **[rmyndharis/antigravity-skills](https://github.com/rmyndharis/antigravity-skills)**: For the massive contribution of 300+ Enterprise skills and the catalog generation logic.
+
 - **[obra/superpowers](https://github.com/obra/superpowers)**: The original "Superpowers" by Jesse Vincent.
 - **[guanyang/antigravity-skills](https://github.com/guanyang/antigravity-skills)**: Core Antigravity extensions.
 - **[diet103/claude-code-infrastructure-showcase](https://github.com/diet103/claude-code-infrastructure-showcase)**: Infrastructure and Backend/Frontend Guidelines.
@@ -394,6 +200,9 @@ This collection would not be possible without the incredible work of the Claude
 - **[vibeforge1111/vibeship-spawner-skills](https://github.com/vibeforge1111/vibeship-spawner-skills)**: AI Agents, Integrations, Maker Tools (57 skills, Apache 2.0).
 - **[coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills)**: Marketing skills for CRO, copywriting, SEO, paid ads, and growth (23 skills, MIT).
 - **[vudovn/antigravity-kit](https://github.com/vudovn/antigravity-kit)**: AI Agent templates with Skills, Agents, and Workflows (33 skills, MIT).
+- **[affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)**: Complete Claude Code configuration collection from Anthropic hackathon winner - skills only (8 skills, MIT).
+- **[webzler/agentMemory](https://github.com/webzler/agentMemory)**: Source for the agent-memory-mcp skill.
+- **[sstklen/claude-api-cost-optimization](https://github.com/sstklen/claude-api-cost-optimization)**: Save 50-90% on Claude API costs with smart optimization strategies (MIT).
 
 ### Inspirations
 
@@ -406,13 +215,16 @@ This collection would not be possible without the incredible work of the Claude
 
 MIT License. See [LICENSE](LICENSE) for details.
 
----
+## Community
 
-**Keywords**: Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode, Agentic Skills, AI Coding Assistant, AI Agent Skills, MCP, MCT, AI Agents, Autonomous Coding, Security Auditing, React Patterns, LLM Tools, AI IDE, Coding AI, AI Pair Programming, Vibe Coding, Agentic Coding, AI Developer Tools.
+- [Community Guidelines](docs/COMMUNITY_GUIDELINES.md)
+- [Security Policy](docs/SECURITY_GUARDRAILS.md)
 
 ---
 
-## 🏷️ GitHub Topics
+---
+
+## GitHub Topics
 
 For repository maintainers, add these topics to maximize discoverability:
 
@@ -420,6 +232,39 @@ For repository maintainers, add these topics to maximize discoverability:
 claude-code, gemini-cli, codex-cli, antigravity, cursor, github-copilot, opencode,
 agentic-skills, ai-coding, llm-tools, ai-agents, autonomous-coding, mcp,
 ai-developer-tools, ai-pair-programming, vibe-coding, skill, skills, SKILL.md, rules.md, CLAUDE.md, GEMINI.md, CURSOR.md
-claude-code, gemini-cli, codex-cli, antigravity, cursor, github-copilot, opencode,
-agentic-skills, ai-coding, llm-tools, ai-agents, autonomous-coding, mcp
 ```
+
+---
+
+## Repo Contributors
+
+We officially thank the following contributors for their help in making this repository awesome!
+
+- [mvanhorn](https://github.com/mvanhorn)
+- [rookie-ricardo](https://github.com/rookie-ricardo)
+- [sck_0](https://github.com/sck_0)
+- [Munir Abbasi](https://github.com/munirabbasi)
+- [Mohammad Faiz](https://github.com/mohdfaiz2k9)
+- [Ianj332](https://github.com/Ianj332)
+- [sickn33](https://github.com/sickn33)
+- [GuppyTheCat](https://github.com/GuppyTheCat)
+- [Tiger-Foxx](https://github.com/Tiger-Foxx)
+- [arathiesh](https://github.com/arathiesh)
+- [1bcMax](https://github.com/1bcMax)
+- [Ahmed Rehan](https://github.com/ar27111994)
+- [BenedictKing](https://github.com/BenedictKing)
+- [Nguyen Huu Loc](https://github.com/LocNguyenSGU)
+- [Owen Wu](https://github.com/yubing744)
+- [SuperJMN](https://github.com/SuperJMN)
+- [Viktor Ferenczi](https://github.com/viktor-ferenczi)
+- [Đỗ Khắc Gia Khoa](https://github.com/Dokhacgiakhoa) - Vietnamese translations (PR #38)
+- [junited31](https://github.com/junited31) - unreal-engine-cpp-pro skill (PR #39)
+- [krisnasantosa15](https://github.com/krisnasantosa15)
+- [raeef1001](https://github.com/raeef1001)
+- [taksrules](https://github.com/taksrules)
+- [zebbern](https://github.com/zebbern)
+- [vuth-dogo](https://github.com/vuth-dogo)
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=sickn33/antigravity-awesome-skills&type=date&legend=top-left)](https://www.star-history.com/#sickn33/antigravity-awesome-skills&type=date&legend=top-left)

RELEASE_NOTES.md

@@ -0,0 +1,41 @@
+# Release v4.1.0: Internationalization & Game Development
+
+> **Vietnamese translations and Unreal Engine C++ expertise added to the skills collection**
+
+This release brings comprehensive Vietnamese language support for documentation and adds professional Unreal Engine 5.x C++ development guidance, expanding the repository's international reach and game development capabilities.
+
+## 🚀 New Skills
+
+### 🎮 [unreal-engine-cpp-pro](skills/unreal-engine-cpp-pro/)
+
+**Expert-level Unreal Engine 5.x C++ development guide**
+
+Comprehensive guide for developing robust, performant C++ code in Unreal Engine 5. Covers UObject hygiene, garbage collection patterns, performance optimization, and Epic Games' coding standards.
+
+- **UObject & Garbage Collection**: Proper UPROPERTY usage, TStrongObjectPtr patterns, IsValid() checks
+- **Performance Optimization**: Tick management, casting optimization, struct vs class decisions
+- **Naming Conventions**: Strict adherence to Epic Games' coding standards (T, U, A, F, E, I prefixes)
+- **Common Patterns**: Component lookup, interface implementation, async loading with soft references
+- **Example Code**: Complete Actor implementation demonstrating best practices
+
+> **Try it:** `"Help me write a C++ Actor class for Unreal Engine 5"` or `"Show me how to properly use UPROPERTY in Unreal Engine"`
+
+---
+
+## 📦 Improvements
+
+- **Registry Update**: Now tracking 560 skills (was 559).
+- **Internationalization**: Added comprehensive Vietnamese translations for all core documentation
+- **Documentation Structure**: Reorganized Vietnamese translations from `docs/vi/` to `docs/vietnamese/` for consistency
+- **Translation Coverage**: Vietnamese versions now available for README, GETTING_STARTED, CONTRIBUTING, FAQ, SECURITY, QUALITY_BAR, SKILL_ANATOMY, and more
+
+## 👥 Credits
+
+A huge shoutout to our community contributors:
+
+- **@Dokhacgiakhoa** for comprehensive Vietnamese translations (PR #38)
+- **@junited31** for `unreal-engine-cpp-pro` skill (PR #39)
+
+---
+
+_Upgrade now: `git pull origin main` to fetch the latest skills._

SECURITY.md

@@ -0,0 +1,19 @@
+# Security Policy
+
+## Supported Versions
+
+We track the `main` branch.
+
+## Reporting a Vulnerability
+
+**DO NOT** open a public Issue for security exploits.
+
+If you find a security vulnerability (e.g., a skill that bypasses the "Authorized Use Only" check or executes malicious code without warning):
+
+1. Email: `security@antigravity.dev` (Placeholder)
+2. Or open a **Private Advisory** on this repository.
+
+## Offensive Skills Policy
+
+Please read our [Security Guardrails](docs/SECURITY_GUARDRAILS.md).
+All offensive skills are strictly for **authorized educational and professional use only**.

data/aliases.json

@@ -0,0 +1,111 @@
+{
+  "generatedAt": "2026-01-28T16:10:28.837Z",
+  "aliases": {
+    "accessibility-compliance-audit": "accessibility-compliance-accessibility-audit",
+    "active directory attacks": "active-directory-attacks",
+    "agent-orchestration-improve": "agent-orchestration-improve-agent",
+    "agent-orchestration-optimize": "agent-orchestration-multi-agent-optimize",
+    "api fuzzing for bug bounty": "api-fuzzing-bug-bounty",
+    "api-testing-mock": "api-testing-observability-api-mock",
+    "application-performance-optimization": "application-performance-performance-optimization",
+    "aws penetration testing": "aws-penetration-testing",
+    "backend-development-feature": "backend-development-feature-development",
+    "brand-guidelines": "brand-guidelines-anthropic",
+    "broken authentication testing": "broken-authentication",
+    "burp suite web application testing": "burp-suite-testing",
+    "c4-architecture": "c4-architecture-c4-architecture",
+    "backend-patterns": "cc-skill-backend-patterns",
+    "clickhouse-io": "cc-skill-clickhouse-io",
+    "coding-standards": "cc-skill-coding-standards",
+    "cc-skill-learning": "cc-skill-continuous-learning",
+    "frontend-patterns": "cc-skill-frontend-patterns",
+    "cc-skill-example": "cc-skill-project-guidelines-example",
+    "security-review": "cc-skill-security-review",
+    "cicd-automation-automate": "cicd-automation-workflow-automate",
+    "claude code guide": "claude-code-guide",
+    "d3-viz": "claude-d3js-skill",
+    "cloud penetration testing": "cloud-penetration-testing",
+    "code-documentation-explain": "code-documentation-code-explain",
+    "code-documentation-generate": "code-documentation-doc-generate",
+    "code-refactoring-restore": "code-refactoring-context-restore",
+    "code-refactoring-clean": "code-refactoring-refactor-clean",
+    "codebase-cleanup-clean": "codebase-cleanup-refactor-clean",
+    "comprehensive-review-full": "comprehensive-review-full-review",
+    "comprehensive-review-enhance": "comprehensive-review-pr-enhance",
+    "context-management-restore": "context-management-context-restore",
+    "context-management-save": "context-management-context-save",
+    "data-engineering-feature": "data-engineering-data-driven-feature",
+    "data-engineering-pipeline": "data-engineering-data-pipeline",
+    "database-cloud-optimize": "database-cloud-optimization-cost-optimize",
+    "database-migrations-observability": "database-migrations-migration-observability",
+    "database-migrations-sql": "database-migrations-sql-migrations",
+    "debugging-toolkit-debug": "debugging-toolkit-smart-debug",
+    "dependency-management-audit": "dependency-management-deps-audit",
+    "deployment-validation-validate": "deployment-validation-config-validate",
+    "distributed-debugging-trace": "distributed-debugging-debug-trace",
+    "documentation-generation-generate": "documentation-generation-doc-generate",
+    "error-debugging-analysis": "error-debugging-error-analysis",
+    "error-debugging-review": "error-debugging-multi-agent-review",
+    "error-diagnostics-analysis": "error-diagnostics-error-analysis",
+    "error-diagnostics-trace": "error-diagnostics-error-trace",
+    "error-diagnostics-debug": "error-diagnostics-smart-debug",
+    "ethical hacking methodology": "ethical-hacking-methodology",
+    "file path traversal testing": "file-path-traversal",
+    "finishing-a-branch": "finishing-a-development-branch",
+    "framework-migration-migrate": "framework-migration-code-migrate",
+    "framework-migration-upgrade": "framework-migration-deps-upgrade",
+    "framework-migration-modernize": "framework-migration-legacy-modernize",
+    "frontend-mobile-scaffold": "frontend-mobile-development-component-scaffold",
+    "frontend-mobile-scan": "frontend-mobile-security-xss-scan",
+    "full-stack-feature": "full-stack-orchestration-full-stack-feature",
+    "git-pr-workflow": "git-pr-workflows-git-workflow",
+    "html injection testing": "html-injection-testing",
+    "idor vulnerability testing": "idor-testing",
+    "incident-response": "incident-response-incident-response",
+    "infinite gratitude": "infinite-gratitude",
+    "internal-comms": "internal-comms-anthropic",
+    "javascript-typescript-scaffold": "javascript-typescript-typescript-scaffold",
+    "linux privilege escalation": "linux-privilege-escalation",
+    "linux production shell scripts": "linux-shell-scripting",
+    "llm-application-assistant": "llm-application-dev-ai-assistant",
+    "llm-application-agent": "llm-application-dev-langchain-agent",
+    "llm-application-optimize": "llm-application-dev-prompt-optimize",
+    "machine-learning-pipeline": "machine-learning-ops-ml-pipeline",
+    "metasploit framework": "metasploit-framework",
+    "moodle-external-development": "moodle-external-api-development",
+    "multi-platform-apps": "multi-platform-apps-multi-platform",
+    "network 101": "network-101",
+    "observability-monitoring-setup": "observability-monitoring-monitor-setup",
+    "observability-monitoring-implement": "observability-monitoring-slo-implement",
+    "obsidian-clipper-creator": "obsidian-clipper-template-creator",
+    "pentest checklist": "pentest-checklist",
+    "pentest commands": "pentest-commands",
+    "performance-testing-ai": "performance-testing-review-ai-review",
+    "performance-testing-agent": "performance-testing-review-multi-agent-review",
+    "supabase-postgres-best-practices": "postgres-best-practices",
+    "privilege escalation methods": "privilege-escalation-methods",
+    "python-development-scaffold": "python-development-python-scaffold",
+    "vercel-react-best-practices": "react-best-practices",
+    "red team tools and methodology": "red-team-tools",
+    "security scanning tools": "scanning-tools",
+    "security-compliance-check": "security-compliance-compliance-check",
+    "security-scanning-dependencies": "security-scanning-security-dependencies",
+    "security-scanning-hardening": "security-scanning-security-hardening",
+    "security-scanning-sast": "security-scanning-security-sast",
+    "shodan reconnaissance and pentesting": "shodan-reconnaissance",
+    "smtp penetration testing": "smtp-penetration-testing",
+    "sql injection testing": "sql-injection-testing",
+    "sqlmap database penetration testing": "sqlmap-database-pentesting",
+    "ssh penetration testing": "ssh-penetration-testing",
+    "startup-business-case": "startup-business-analyst-business-case",
+    "startup-business-projections": "startup-business-analyst-financial-projections",
+    "startup-business-opportunity": "startup-business-analyst-market-opportunity",
+    "systems-programming-project": "systems-programming-rust-project",
+    "team-collaboration-notes": "team-collaboration-standup-notes",
+    "top 100 web vulnerabilities reference": "top-web-vulnerabilities",
+    "windows privilege escalation": "windows-privilege-escalation",
+    "wireshark network traffic analysis": "wireshark-analysis",
+    "wordpress penetration testing": "wordpress-penetration-testing",
+    "cross-site scripting and html injection testing": "xss-html-injection"
+  }
+}

data/bundles.json

@@ -0,0 +1,403 @@
+{
+  "generatedAt": "2026-01-28T16:10:28.837Z",
+  "bundles": {
+    "core-dev": {
+      "description": "Core development skills across languages, frameworks, and backend/frontend fundamentals.",
+      "skills": [
+        "3d-web-experience",
+        "algolia-search",
+        "api-design-principles",
+        "api-documentation-generator",
+        "api-documenter",
+        "api-fuzzing-bug-bounty",
+        "api-patterns",
+        "api-security-best-practices",
+        "api-testing-observability-api-mock",
+        "app-store-optimization",
+        "application-performance-performance-optimization",
+        "architecture-patterns",
+        "async-python-patterns",
+        "autonomous-agents",
+        "aws-serverless",
+        "azure-functions",
+        "backend-architect",
+        "backend-dev-guidelines",
+        "backend-development-feature-development",
+        "backend-security-coder",
+        "bullmq-specialist",
+        "bun-development",
+        "cc-skill-backend-patterns",
+        "cc-skill-coding-standards",
+        "cc-skill-frontend-patterns",
+        "cc-skill-security-review",
+        "claude-d3js-skill",
+        "code-documentation-doc-generate",
+        "context7-auto-research",
+        "discord-bot-architect",
+        "django-pro",
+        "documentation-generation-doc-generate",
+        "documentation-templates",
+        "dotnet-architect",
+        "dotnet-backend-patterns",
+        "exa-search",
+        "fastapi-pro",
+        "fastapi-templates",
+        "firebase",
+        "firecrawl-scraper",
+        "flutter-expert",
+        "frontend-design",
+        "frontend-dev-guidelines",
+        "frontend-developer",
+        "frontend-mobile-development-component-scaffold",
+        "frontend-mobile-security-xss-scan",
+        "frontend-security-coder",
+        "go-concurrency-patterns",
+        "golang-pro",
+        "graphql",
+        "hubspot-integration",
+        "ios-developer",
+        "java-pro",
+        "javascript-mastery",
+        "javascript-pro",
+        "javascript-testing-patterns",
+        "javascript-typescript-typescript-scaffold",
+        "langgraph",
+        "launch-strategy",
+        "mcp-builder",
+        "memory-safety-patterns",
+        "mobile-design",
+        "mobile-developer",
+        "mobile-security-coder",
+        "modern-javascript-patterns",
+        "moodle-external-api-development",
+        "multi-platform-apps-multi-platform",
+        "nextjs-app-router-patterns",
+        "nextjs-best-practices",
+        "nextjs-supabase-auth",
+        "nodejs-backend-patterns",
+        "nodejs-best-practices",
+        "openapi-spec-generation",
+        "php-pro",
+        "plaid-fintech",
+        "product-manager-toolkit",
+        "python-development-python-scaffold",
+        "python-packaging",
+        "python-patterns",
+        "python-performance-optimization",
+        "python-pro",
+        "python-testing-patterns",
+        "react-best-practices",
+        "react-modernization",
+        "react-native-architecture",
+        "react-patterns",
+        "react-state-management",
+        "react-ui-patterns",
+        "reference-builder",
+        "remotion-best-practices",
+        "ruby-pro",
+        "rust-async-patterns",
+        "rust-pro",
+        "senior-architect",
+        "senior-fullstack",
+        "shodan-reconnaissance",
+        "shopify-apps",
+        "shopify-development",
+        "slack-bot-builder",
+        "systems-programming-rust-project",
+        "tavily-web",
+        "telegram-bot-builder",
+        "telegram-mini-app",
+        "temporal-python-pro",
+        "temporal-python-testing",
+        "top-web-vulnerabilities",
+        "trigger-dev",
+        "twilio-communications",
+        "typescript-advanced-types",
+        "typescript-expert",
+        "typescript-pro",
+        "ui-ux-pro-max",
+        "uv-package-manager",
+        "viral-generator-builder",
+        "voice-agents",
+        "voice-ai-development",
+        "web-artifacts-builder",
+        "webapp-testing"
+      ]
+    },
+    "security-core": {
+      "description": "Security, privacy, and compliance essentials.",
+      "skills": [
+        "accessibility-compliance-accessibility-audit",
+        "api-fuzzing-bug-bounty",
+        "api-security-best-practices",
+        "attack-tree-construction",
+        "auth-implementation-patterns",
+        "aws-penetration-testing",
+        "backend-security-coder",
+        "broken-authentication",
+        "burp-suite-testing",
+        "cc-skill-security-review",
+        "cicd-automation-workflow-automate",
+        "clerk-auth",
+        "cloud-architect",
+        "cloud-penetration-testing",
+        "code-review-checklist",
+        "code-reviewer",
+        "codebase-cleanup-deps-audit",
+        "computer-use-agents",
+        "database-admin",
+        "dependency-management-deps-audit",
+        "deployment-engineer",
+        "deployment-pipeline-design",
+        "design-orchestration",
+        "docker-expert",
+        "ethical-hacking-methodology",
+        "firebase",
+        "firmware-analyst",
+        "form-cro",
+        "framework-migration-deps-upgrade",
+        "frontend-mobile-security-xss-scan",
+        "frontend-security-coder",
+        "gdpr-data-handling",
+        "graphql-architect",
+        "hybrid-cloud-architect",
+        "idor-testing",
+        "k8s-manifest-generator",
+        "k8s-security-policies",
+        "kubernetes-architect",
+        "legal-advisor",
+        "linkerd-patterns",
+        "loki-mode",
+        "malware-analyst",
+        "metasploit-framework",
+        "mobile-security-coder",
+        "multi-agent-brainstorming",
+        "network-engineer",
+        "nextjs-supabase-auth",
+        "nodejs-best-practices",
+        "notebooklm",
+        "openapi-spec-generation",
+        "payment-integration",
+        "pci-compliance",
+        "pentest-checklist",
+        "plaid-fintech",
+        "quant-analyst",
+        "red-team-tools",
+        "reverse-engineer",
+        "risk-manager",
+        "risk-metrics-calculation",
+        "sast-configuration",
+        "scanning-tools",
+        "secrets-management",
+        "security-auditor",
+        "security-compliance-compliance-check",
+        "security-requirement-extraction",
+        "security-scanning-security-dependencies",
+        "security-scanning-security-hardening",
+        "security-scanning-security-sast",
+        "service-mesh-expert",
+        "smtp-penetration-testing",
+        "solidity-security",
+        "ssh-penetration-testing",
+        "stride-analysis-patterns",
+        "stripe-integration",
+        "terraform-specialist",
+        "threat-mitigation-mapping",
+        "threat-modeling-expert",
+        "top-web-vulnerabilities",
+        "twilio-communications",
+        "ui-visual-validator",
+        "vulnerability-scanner",
+        "web-design-guidelines",
+        "wordpress-penetration-testing",
+        "xss-html-injection"
+      ]
+    },
+    "k8s-core": {
+      "description": "Kubernetes and service mesh essentials.",
+      "skills": [
+        "backend-architect",
+        "devops-troubleshooter",
+        "gitops-workflow",
+        "helm-chart-scaffolding",
+        "istio-traffic-management",
+        "k8s-manifest-generator",
+        "k8s-security-policies",
+        "kubernetes-architect",
+        "legal-advisor",
+        "linkerd-patterns",
+        "microservices-patterns",
+        "moodle-external-api-development",
+        "mtls-configuration",
+        "network-engineer",
+        "observability-monitoring-slo-implement",
+        "service-mesh-expert",
+        "service-mesh-observability",
+        "slo-implementation"
+      ]
+    },
+    "data-core": {
+      "description": "Data engineering and analytics foundations.",
+      "skills": [
+        "airflow-dag-patterns",
+        "analytics-tracking",
+        "blockrun",
+        "business-analyst",
+        "cc-skill-backend-patterns",
+        "cc-skill-clickhouse-io",
+        "claude-d3js-skill",
+        "content-marketer",
+        "data-engineer",
+        "data-engineering-data-driven-feature",
+        "data-engineering-data-pipeline",
+        "data-quality-frameworks",
+        "data-scientist",
+        "data-storytelling",
+        "database-admin",
+        "database-architect",
+        "database-cloud-optimization-cost-optimize",
+        "database-design",
+        "database-migration",
+        "database-migrations-migration-observability",
+        "database-migrations-sql-migrations",
+        "database-optimizer",
+        "dbt-transformation-patterns",
+        "firebase",
+        "frontend-dev-guidelines",
+        "gdpr-data-handling",
+        "graphql",
+        "hybrid-cloud-networking",
+        "idor-testing",
+        "ios-developer",
+        "kpi-dashboard-design",
+        "legal-advisor",
+        "loki-mode",
+        "ml-pipeline-workflow",
+        "moodle-external-api-development",
+        "neon-postgres",
+        "nextjs-app-router-patterns",
+        "nextjs-best-practices",
+        "nodejs-backend-patterns",
+        "pci-compliance",
+        "php-pro",
+        "postgres-best-practices",
+        "postgresql",
+        "prisma-expert",
+        "programmatic-seo",
+        "quant-analyst",
+        "react-best-practices",
+        "react-ui-patterns",
+        "scala-pro",
+        "schema-markup",
+        "segment-cdp",
+        "senior-architect",
+        "seo-audit",
+        "spark-optimization",
+        "sql-injection-testing",
+        "sql-optimization-patterns",
+        "sql-pro",
+        "sqlmap-database-pentesting",
+        "unity-ecs-patterns",
+        "vector-database-engineer",
+        "xlsx",
+        "xlsx-official"
+      ]
+    },
+    "ops-core": {
+      "description": "Operations, observability, and delivery pipelines.",
+      "skills": [
+        "agent-evaluation",
+        "airflow-dag-patterns",
+        "api-testing-observability-api-mock",
+        "application-performance-performance-optimization",
+        "aws-serverless",
+        "backend-architect",
+        "backend-development-feature-development",
+        "c4-container",
+        "cicd-automation-workflow-automate",
+        "code-review-ai-ai-review",
+        "data-engineer",
+        "data-engineering-data-pipeline",
+        "database-migration",
+        "database-migrations-migration-observability",
+        "database-optimizer",
+        "deployment-engineer",
+        "deployment-pipeline-design",
+        "deployment-procedures",
+        "deployment-validation-config-validate",
+        "devops-troubleshooter",
+        "distributed-debugging-debug-trace",
+        "distributed-tracing",
+        "django-pro",
+        "docker-expert",
+        "e2e-testing-patterns",
+        "error-debugging-error-analysis",
+        "error-debugging-error-trace",
+        "error-diagnostics-error-analysis",
+        "error-diagnostics-error-trace",
+        "flutter-expert",
+        "git-pr-workflows-git-workflow",
+        "gitlab-ci-patterns",
+        "gitops-workflow",
+        "grafana-dashboards",
+        "incident-responder",
+        "incident-response-incident-response",
+        "incident-response-smart-fix",
+        "incident-runbook-templates",
+        "internal-comms-anthropic",
+        "internal-comms-community",
+        "kpi-dashboard-design",
+        "kubernetes-architect",
+        "langfuse",
+        "llm-app-patterns",
+        "loki-mode",
+        "machine-learning-ops-ml-pipeline",
+        "malware-analyst",
+        "ml-engineer",
+        "ml-pipeline-workflow",
+        "mlops-engineer",
+        "observability-engineer",
+        "observability-monitoring-monitor-setup",
+        "observability-monitoring-slo-implement",
+        "performance-engineer",
+        "performance-testing-review-ai-review",
+        "postmortem-writing",
+        "prometheus-configuration",
+        "risk-metrics-calculation",
+        "security-auditor",
+        "server-management",
+        "service-mesh-expert",
+        "service-mesh-observability",
+        "slo-implementation",
+        "temporal-python-pro",
+        "terraform-specialist",
+        "unity-developer",
+        "vercel-deployment",
+        "voice-agents",
+        "writing-skills"
+      ]
+    }
+  },
+  "common": [
+    "bash-pro",
+    "python-pro",
+    "javascript-pro",
+    "typescript-pro",
+    "golang-pro",
+    "rust-pro",
+    "java-pro",
+    "frontend-developer",
+    "backend-architect",
+    "nodejs-backend-patterns",
+    "fastapi-pro",
+    "api-design-principles",
+    "sql-pro",
+    "database-architect",
+    "kubernetes-architect",
+    "terraform-specialist",
+    "observability-engineer",
+    "security-auditor",
+    "sast-configuration",
+    "gitops-workflow"
+  ]
+}

data/package-lock.json

@@ -0,0 +1,27 @@
+{
+  "name": "antigravity-awesome-skills",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "yaml": "^2.8.2"
+      }
+    },
+    "node_modules/yaml": {
+      "version": "2.8.2",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
+      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
+      }
+    }
+  }
+}

data/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "antigravity-awesome-skills",
+  "version": "4.0.0",
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}

docs/BUNDLES.md

@@ -0,0 +1,124 @@
+# 📦 Antigravity Skill Bundles
+
+Don't know where to start? Pick a bundle below to get a curated set of skills for your role.
+
+## 🚀 The "Essentials" Starter Pack
+
+_For everyone. Install these first._
+
+- `concise-planning`: Always start with a plan.
+- `lint-and-validate`: Keep your code clean automatically.
+- `git-pushing`: Save your work safely.
+- `kaizen`: Continuous improvement mindset.
+
+## 🛡️ The "Security Engineer" Pack
+
+_For pentesting, auditing, and hardening._
+
+- `ethical-hacking-methodology`: The Bible of ethical hacking.
+- `burp-suite-testing`: Web vulnerability scanning.
+- `owasp-top-10`: Check for the most common flaws.
+- `linux-privilege-escalation`: Advanced Linux security assessment.
+- `cloud-penetration-testing`: AWS/Azure/GCP security.
+
+## 🌐 The "Web Wizard" Pack
+
+_For building modern, high-performance web apps._
+
+- `frontend-design`: UI guidelines and aesthetics.
+- `react-patterns`: Best practices for React (if available).
+- `tailwind-patterns`: Styling superpowers.
+- `form-cro`: Optimize your forms for conversion.
+- `seo-audit`: Get found on Google.
+
+## 🤖 The "Agent Architect" Pack
+
+_For building AI systems._
+
+- `agent-evaluation`: Test your agents.
+- `langgraph`: Build stateful agent workflows.
+- `mcp-builder`: Create your own tools.
+- `prompt-engineering`: Master the art of talking to LLMs.
+
+## 🎮 The "Indie Game Dev" Pack
+
+_For building games with AI assistants._
+
+- `game-development/game-design`: Mechanics and loops.
+- `game-development/2d-games`: Sprites and physics.
+- `game-development/3d-games`: Models and shaders.
+- `game-development/unity-csharp`: C# scripting mastery.
+- `algorithmic-art`: Generate assets with code.
+
+## 🐍 The "Python Pro" Pack
+
+_For backend heavyweights and data scientists._
+
+- `python-patterns`: Idiomatic Python code.
+- `poetry-manager`: Dependency management that works.
+- `pytest-mastery`: Testing frameworks.
+- `fastapi-expert`: High-performance APIs.
+- `django-guide`: The battery-included framework.
+
+## 🦄 The "Startup Founder" Pack
+
+_For building products, not just code._
+
+- `product-requirements-doc`: Define what to build.
+- `competitor-analysis`: Know who you are fighting.
+- `pitch-deck-creator`: Raise capital (or just explain your idea).
+- `landing-page-copy`: Write words that sell.
+- `stripe-integration`: Get paid.
+
+## 🌧️ The "DevOps & Cloud" Pack
+
+_For infrastructure and scaling._
+
+- `docker-expert`: Master containers and multi-stage builds.
+- `aws-serverless`: Go serverless on AWS (Lambda, DynamoDB).
+- `environment-setup-guide`: Standardization for teams.
+- `deployment-procedures`: Safe rollout strategies.
+- `bash-linux`: Terminal wizardry.
+
+## 📊 The "Data & Analytics" Pack
+
+_For making sense of the numbers._
+
+- `analytics-tracking`: Set up GA4/PostHog correctly.
+- `d3-viz`: Beautiful custom visualizations.
+- `sql-mastery`: Write better queries (Community skill).
+- `ab-test-setup`: Validated learning.
+
+## 🎨 The "Creative Director" Pack
+
+_For visuals, content, and branding._
+
+- `canvas-design`: Generate posters and diagrams.
+- `frontend-design`: UI aesthetics.
+- `content-creator`: SEO-optimized blog posts.
+- `copy-editing`: Polish your prose.
+- `algorithmic-art`: Code-generated masterpieces.
+
+## 🐞 The "QA & Testing" Pack
+
+_For breaking things before users do._
+
+- `test-driven-development`: Red, Green, Refactor.
+- `systematic-debugging`: Sherlock Holmes for code.
+- `browser-automation`: End-to-end testing with Playwright.
+- `ab-test-setup`: Validated experiments.
+- `code-review-checklist`: Catch bugs in PRs.
+
+## 🖌️ The "Web Designer" Pack
+
+_For pixel-perfect experiences._
+
+- `ui-ux-pro-max`: Premium design systems/tokens.
+- `frontend-design`: The base layer of aesthetics.
+- `3d-web-experience`: Three.js & R3F magic.
+- `canvas-design`: Static visuals/posters.
+- `responsive-layout`: Mobile-first principles.
+
+---
+
+_To use a bundle, simply copy the skill names into your `.agent/skills` folder or use them with your agent._

docs/CI_DRIFT_FIX.md

@@ -0,0 +1,39 @@
+# CI Drift Fix Guide
+
+**Problem**: The failing job is caused by uncommitted changes detected in `README.md` or `skills_index.json` after the update scripts run.
+
+**Error**:
+
+```
+❌ Detected uncommitted changes in README.md or skills_index.json. Please run scripts locally and commit.
+```
+
+**Cause**:
+Scripts like `scripts/generate_index.py` and `scripts/update_readme.py` modify `README.md` and `skills_index.json`, but the workflow expects these files to have no changes after the scripts are run. Any differences mean the committed repo is out-of-sync with what the generation scripts produce.
+
+**How to Fix (DO THIS EVERY TIME):**
+
+1. Run the **FULL Validation Chain** locally to regenerate `README.md` e `skills_index.json`:
+
+   ```bash
+   python3 scripts/validate_skills.py
+   python3 scripts/generate_index.py
+   python3 scripts/update_readme.py
+   ```
+
+2. Check for changes:
+
+   ```bash
+   git status
+   git diff
+   ```
+
+3. Commit and push any updates:
+   ```bash
+   git add README.md skills_index.json
+   git commit -m "chore: sync generated registry files"
+   git push
+   ```
+
+**Summary**:
+Always commit and push all changes produced by the registry or readme update scripts. This keeps the CI workflow passing by ensuring the repository and generated files are synced.

docs/COMMUNITY_GUIDELINES.md

@@ -0,0 +1,33 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Enforcement
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1.
+
+[homepage]: https://www.contributor-covenant.org

docs/EXAMPLES.md

@@ -1,760 +1,56 @@
-# 💡 Real-World Examples - See Skills in Action
+# 🧪 Real-World Examples ("The Antigravity Cookbook")
 
-**Learn by example!** This guide shows you real conversations using different skills.
+Skills are powerful on their own, but unstoppable when combined.
+Here are three common scenarios and how to solve them using this repository.
+
+## 🥘 Recipe 1: The "Legacy Code Audit"
+
+_Scenario: You just inherited a messy 5-year-old Node.js repo. You need to fix it safely._
+
+**Skills Used:**
+
+1. `concise-planning` (To map the chaos)
+2. `lint-and-validate` (To find the bugs)
+3. `security-audit` (To find the holes)
+
+**The Workflow:**
+
+1. **Plan**: "Agent, use `concise-planning` to create a checklist for refactoring `src/legacy-api.js`."
+2. **Audit**: "Run `security-audit` on the `package.json` to find vulnerable dependencies."
+3. **Fix**: "Use `lint-and-validate` rules to auto-fix the formatting issues in `src/`."
 
 ---
 
-## Example 1: Designing a Feature with @brainstorming
+## 🥘 Recipe 2: The "Modern Web App"
 
-### The Scenario
-You want to add a "dark mode" feature to your app, but you're not sure how to approach it.
+_Scenario: You need to build a high-performance Landing Page in 2 hours._
 
-### The Conversation
+**Skills Used:**
 
-```
-You: @brainstorming I want to add dark mode to my React app
+1. `frontend-design` (For aesthetics)
+2. `react-patterns` (For structure)
+3. `tailwind-mastery` (For speed)
 
-AI: Great! Let me help you think through this. First, let me check your 
-    current project structure...
-    
-    [AI examines your files]
-    
-    I see you're using React with Tailwind CSS. Now, let's understand 
-    your requirements:
-    
-    What's your primary goal for dark mode?
-    a) User preference (toggle in settings)
-    b) System preference (follow OS setting)
-    c) Both (with manual override)
+**The Workflow:**
 
-You: c) Both
-
-AI: Perfect! That's the best user experience. Next question:
-    
-    Where should the dark mode toggle be located?
-    a) In the main navigation
-    b) In a settings page
-    c) In a dropdown menu
-    d) Multiple locations
-
-You: a) In the main navigation
-
-AI: Good choice for accessibility. One more question:
-    
-    Should dark mode preference persist across sessions?
-    a) Yes, save to localStorage
-    b) Yes, save to user account (requires backend)
-    c) No, reset each session
-
-You: a) Yes, save to localStorage
-
-AI: Excellent! Now I have a clear picture. Let me present the design...
-    
-    ## Dark Mode Implementation Design
-    
-    ### Architecture Overview
-    We'll use React Context for state management, Tailwind's dark mode
-    utilities, and localStorage for persistence. The system will:
-    1. Check OS preference on first visit
-    2. Allow manual override via toggle
-    3. Persist preference in localStorage
-    
-    Does this approach look good so far?
-
-You: Yes, continue
-
-AI: [Continues with detailed design sections...]
-    
-    [After design is complete]
-    
-    I've saved the design to docs/plans/2026-01-20-dark-mode-design.md
-    
-    Ready to set up for implementation?
-
-You: Yes
-
-AI: I'll create an isolated workspace using git worktrees and write an
-    implementation plan. One moment...
-```
-
-### What Happened
-- ✅ AI asked focused questions one at a time
-- ✅ Explored your specific context
-- ✅ Presented design in sections
-- ✅ Saved documentation
-- ✅ Prepared for implementation
+1. **Design**: "Use `frontend-design` to generate a color palette and typography for a 'Cyberpunk Coffee Shop'."
+2. **Scaffold**: "Initialize a Vite project. Then apply `react-patterns` to create the 'Hero' component."
+3. **Style**: "Use `tailwind-mastery` to make the buttons glassmorphic and responsive."
 
 ---
 
-## Example 2: Debugging with @systematic-debugging
+## 🥘 Recipe 3: The "Agent Architect"
 
-### The Scenario
-Your tests are failing, but you're not sure why.
+_Scenario: You want to build a custom AI agent that can verify its own code._
 
-### The Conversation
+**Skills Used:**
 
-```
-You: @systematic-debugging My tests are failing with "Cannot read property 
-     'map' of undefined"
+1. `mcp-builder` (To build tools)
+2. `agent-evaluation` (To test reliability)
+3. `prompt-engineering` (To refine instructions)
 
-AI: Let me help you debug this systematically. First, I'll gather information:
-    
-    1. Running the failing test to see the full error...
-    
-    [AI runs: npm test]
-    
-    I see the error occurs in UserList.test.tsx at line 45. Let me examine
-    the test file and the component...
-    
-    [AI reads both files]
-    
-    ## Hypothesis
-    The test is failing because `users` prop is undefined when the component
-    renders. This suggests the mock data isn't being passed correctly.
-    
-    ## Verification
-    Let me check the test setup...
-    
-    [AI examines test]
-    
-    Found it! The test is calling:
-    ```typescript
-    render(<UserList />)
-    ```
-    
-    But UserList requires a `users` prop. The component expects:
-    ```typescript
-    interface UserListProps {
-      users: User[];
-    }
-    ```
-    
-    ## Solution
-    The test should pass the users prop:
-    ```typescript
-    const mockUsers = [
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' }
-    ];
-    
-    render(<UserList users={mockUsers} />)
-    ```
-    
-    Should I apply this fix?
+**The Workflow:**
 
-You: Yes
-
-AI: [Applies fix and runs tests]
-    
-    ✅ All tests passing!
-    
-    ## Root Cause
-    The test was missing required props. This is a common issue when
-    components are refactored to require props that were previously optional.
-    
-    ## Prevention
-    Consider adding TypeScript strict mode to catch these at compile time:
-    ```json
-    "strict": true,
-    "strictNullChecks": true
-    ```
-    
-    Would you like me to add this to your tsconfig.json?
-```
-
-### What Happened
-- ✅ Systematic investigation
-- ✅ Clear hypothesis
-- ✅ Verification before fixing
-- ✅ Root cause analysis
-- ✅ Prevention suggestions
-
----
-
-## Example 3: Adding Payments with @stripe-integration
-
-### The Scenario
-You need to add subscription billing to your SaaS app.
-
-### The Conversation
-
-```
-You: @stripe-integration I need to add monthly subscription billing
-
-AI: I'll help you implement Stripe subscriptions. Let me understand your
-    requirements:
-    
-    Current stack detected:
-    - Next.js 14 (App Router)
-    - TypeScript
-    - Prisma with PostgreSQL
-    
-    For subscription billing, we'll need:
-    
-    1. **Stripe Setup**
-       - Stripe account and API keys
-       - Webhook endpoint for events
-       - Product and price IDs
-    
-    2. **Backend Implementation**
-       - API routes for checkout
-       - Webhook handler
-       - Database schema for subscriptions
-    
-    3. **Frontend Implementation**
-       - Pricing page
-       - Checkout flow
-       - Subscription management
-    
-    Let's start with the backend. First, install dependencies:
-    
-    ```bash
-    npm install stripe @stripe/stripe-js
-    ```
-    
-    Now, let's create the database schema...
-    
-    [AI provides Prisma schema]
-    
-    ```prisma
-    model User {
-      id                 String    @id @default(cuid())
-      email              String    @unique
-      stripeCustomerId   String?   @unique
-      subscriptions      Subscription[]
-    }
-    
-    model Subscription {
-      id                 String    @id @default(cuid())
-      userId             String
-      user               User      @relation(fields: [userId], references: [id])
-      stripeSubscriptionId String  @unique
-      status             String
-      priceId            String
-      currentPeriodEnd   DateTime
-      createdAt          DateTime  @default(now())
-      updatedAt          DateTime  @updatedAt
-    }
-    ```
-    
-    Next, let's create the checkout API route...
-    
-    [AI provides complete implementation with:]
-    - API route for creating checkout sessions
-    - Webhook handler for subscription events
-    - Helper functions for Stripe operations
-    - Error handling and logging
-    - TypeScript types
-    
-    Now for the frontend...
-    
-    [AI provides:]
-    - Pricing page component
-    - Checkout button component
-    - Subscription status display
-    - Tailwind styling
-    
-    Finally, let's set up the webhook:
-    
-    1. In Stripe Dashboard, add webhook endpoint:
-       `https://yourdomain.com/api/webhooks/stripe`
-    
-    2. Select these events:
-       - customer.subscription.created
-       - customer.subscription.updated
-       - customer.subscription.deleted
-       - invoice.payment_succeeded
-       - invoice.payment_failed
-    
-    3. Copy the webhook secret to your .env:
-       ```
-       STRIPE_WEBHOOK_SECRET=whsec_...
-       ```
-    
-    ## Testing
-    
-    Test locally with Stripe CLI:
-    ```bash
-    stripe listen --forward-to localhost:3000/api/webhooks/stripe
-    stripe trigger customer.subscription.created
-    ```
-    
-    ## Security Checklist
-    - ✅ API keys in environment variables
-    - ✅ Webhook signature verification
-    - ✅ Server-side price validation
-    - ✅ Idempotency keys for operations
-    
-    Ready to test the implementation?
-```
-
-### What Happened
-- ✅ Detected existing stack
-- ✅ Provided complete implementation
-- ✅ Included database schema
-- ✅ Added security best practices
-- ✅ Included testing instructions
-
----
-
-## Example 4: Writing Copy with @copywriting
-
-### The Scenario
-You need compelling copy for your SaaS landing page.
-
-### The Conversation
-
-```
-You: @copywriting Write homepage copy for my project management tool
-
-AI: I'll help you create compelling homepage copy. First, let me understand
-    your product:
-    
-    What makes your project management tool different from competitors
-    like Asana, Trello, or Monday.com?
-
-You: It's specifically built for remote teams with built-in video standups
-     and async communication features
-
-AI: Excellent differentiator! Who is your primary target audience?
-    a) Startups and small teams (2-20 people)
-    b) Mid-size companies (20-200 people)
-    c) Enterprise (200+ people)
-    d) Freelancers and agencies
-
-You: a) Startups and small teams
-
-AI: Perfect. What's the main pain point you solve?
-
-You: Remote teams waste time in unnecessary meetings and lose context
-     in async communication
-
-AI: Great! Now I have what I need. Here's your homepage copy:
-    
-    ---
-    
-    ## Hero Section
-    
-    **Headline:**
-    Run Your Remote Team Without the Meeting Overload
-    
-    **Subheadline:**
-    The project management tool built for distributed teams. Replace 
-    status meetings with async video standups and keep everyone in sync
-    without the Zoom fatigue.
-    
-    **CTA:**
-    Start Free Trial → (No credit card required)
-    
-    ---
-    
-    ## Problem Section
-    
-    **Headline:**
-    Remote Work Shouldn't Mean More Meetings
-    
-    **Body:**
-    Your team is distributed across time zones. You're spending hours in
-    status meetings just to stay aligned. Async updates get lost in Slack.
-    Context disappears. Productivity suffers.
-    
-    Sound familiar?
-    
-    ---
-    
-    ## Solution Section
-    
-    **Headline:**
-    Stay Aligned Without the Meeting Marathon
-    
-    **Features:**
-    
-    📹 **Async Video Standups**
-    Record quick video updates on your schedule. Your team watches when
-    it works for them. No more 9am calls for your teammate in Tokyo.
-    
-    💬 **Context-Rich Communication**
-    Every task, comment, and decision stays connected. No more hunting
-    through Slack threads or email chains.
-    
-    📊 **Visual Progress Tracking**
-    See what's happening at a glance. Kanban boards, timelines, and
-    dashboards that actually make sense.
-    
-    🔔 **Smart Notifications**
-    Get notified about what matters. Ignore the rest. Your focus time
-    is sacred.
-    
-    ---
-    
-    ## Social Proof Section
-    
-    **Headline:**
-    Trusted by Remote Teams Worldwide
-    
-    [Testimonial placeholders with structure]
-    
-    ---
-    
-    ## CTA Section
-    
-    **Headline:**
-    Ready to Reclaim Your Calendar?
-    
-    **Body:**
-    Join 500+ remote teams who've cut meeting time by 60% while staying
-    more aligned than ever.
-    
-    **CTA:**
-    Start Your Free 14-Day Trial →
-    
-    No credit card required. Cancel anytime.
-    
-    ---
-    
-    ## Copy Notes
-    
-    **Tone:** Professional but conversational
-    **Focus:** Pain point (too many meetings) → Solution (async video)
-    **Differentiation:** Built specifically for remote teams
-    **Social proof:** Quantified benefit (60% fewer meetings)
-    
-    Would you like me to:
-    1. Write alternative versions for A/B testing?
-    2. Create copy for specific feature pages?
-    3. Write email sequences for onboarding?
-```
-
-### What Happened
-- ✅ Asked clarifying questions
-- ✅ Identified unique value proposition
-- ✅ Created benefit-focused copy
-- ✅ Included clear CTAs
-- ✅ Provided copy notes for consistency
-
----
-
-## Example 5: Test-Driven Development with @test-driven-development
-
-### The Scenario
-You need to implement a new feature: user authentication.
-
-### The Conversation
-
-```
-You: @test-driven-development I need to implement user login functionality
-
-AI: Perfect! Let's use TDD to build this. Following the Red-Green-Refactor
-    cycle, we'll write tests first, then implement.
-    
-    ## Step 1: Write the First Test (RED)
-    
-    Let's start with the simplest case - successful login:
-    
-    ```typescript
-    // auth.test.ts
-    import { login } from './auth';
-    
-    describe('login', () => {
-      it('should return user data for valid credentials', async () => {
-        const result = await login({
-          email: 'user@example.com',
-          password: 'correct-password'
-        });
-        
-        expect(result.success).toBe(true);
-        expect(result.user).toHaveProperty('id');
-        expect(result.user).toHaveProperty('email');
-        expect(result.token).toBeDefined();
-      });
-    });
-    ```
-    
-    Let's run this test to see it fail:
-    
-    [AI runs: npm test]
-    
-    ✅ Test fails as expected (auth.ts doesn't exist yet)
-    
-    ## Step 2: Write Minimal Implementation (GREEN)
-    
-    Now let's write just enough code to make this test pass:
-    
-    ```typescript
-    // auth.ts
-    interface LoginCredentials {
-      email: string;
-      password: string;
-    }
-    
-    interface LoginResult {
-      success: boolean;
-      user?: {
-        id: string;
-        email: string;
-      };
-      token?: string;
-    }
-    
-    export async function login(
-      credentials: LoginCredentials
-    ): Promise<LoginResult> {
-      // Minimal implementation to pass the test
-      return {
-        success: true,
-        user: {
-          id: '1',
-          email: credentials.email
-        },
-        token: 'fake-token'
-      };
-    }
-    ```
-    
-    [AI runs: npm test]
-    
-    ✅ Test passes!
-    
-    ## Step 3: Add Next Test (RED)
-    
-    Now let's test the failure case:
-    
-    ```typescript
-    it('should return error for invalid credentials', async () => {
-      const result = await login({
-        email: 'user@example.com',
-        password: 'wrong-password'
-      });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Invalid credentials');
-      expect(result.user).toBeUndefined();
-      expect(result.token).toBeUndefined();
-    });
-    ```
-    
-    [AI runs: npm test]
-    
-    ❌ Test fails (always returns success)
-    
-    ## Step 4: Implement Real Logic (GREEN)
-    
-    Now let's add actual authentication:
-    
-    ```typescript
-    import bcrypt from 'bcrypt';
-    import jwt from 'jsonwebtoken';
-    import { db } from './db';
-    
-    export async function login(
-      credentials: LoginCredentials
-    ): Promise<LoginResult> {
-      // Find user
-      const user = await db.user.findUnique({
-        where: { email: credentials.email }
-      });
-      
-      if (!user) {
-        return {
-          success: false,
-          error: 'Invalid credentials'
-        };
-      }
-      
-      // Verify password
-      const validPassword = await bcrypt.compare(
-        credentials.password,
-        user.passwordHash
-      );
-      
-      if (!validPassword) {
-        return {
-          success: false,
-          error: 'Invalid credentials'
-        };
-      }
-      
-      // Generate token
-      const token = jwt.sign(
-        { userId: user.id },
-        process.env.JWT_SECRET!,
-        { expiresIn: '7d' }
-      );
-      
-      return {
-        success: true,
-        user: {
-          id: user.id,
-          email: user.email
-        },
-        token
-      };
-    }
-    ```
-    
-    [AI runs: npm test]
-    
-    ✅ All tests pass!
-    
-    ## Step 5: Add Edge Cases
-    
-    Let's add more tests for edge cases:
-    
-    ```typescript
-    it('should handle missing email', async () => {
-      const result = await login({
-        email: '',
-        password: 'password'
-      });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Email is required');
-    });
-    
-    it('should handle missing password', async () => {
-      const result = await login({
-        email: 'user@example.com',
-        password: ''
-      });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Password is required');
-    });
-    
-    it('should handle database errors gracefully', async () => {
-      // Mock database error
-      jest.spyOn(db.user, 'findUnique').mockRejectedValue(
-        new Error('Database connection failed')
-      );
-      
-      const result = await login({
-        email: 'user@example.com',
-        password: 'password'
-      });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('An error occurred');
-    });
-    ```
-    
-    [AI implements validation and error handling]
-    
-    ## Step 6: Refactor (REFACTOR)
-    
-    Now that all tests pass, let's refactor for better code quality:
-    
-    ```typescript
-    // Extract validation
-    function validateCredentials(credentials: LoginCredentials): string | null {
-      if (!credentials.email) return 'Email is required';
-      if (!credentials.password) return 'Password is required';
-      return null;
-    }
-    
-    // Extract user verification
-    async function verifyUser(
-      email: string,
-      password: string
-    ): Promise<User | null> {
-      const user = await db.user.findUnique({ where: { email } });
-      if (!user) return null;
-      
-      const valid = await bcrypt.compare(password, user.passwordHash);
-      return valid ? user : null;
-    }
-    
-    // Main function is now cleaner
-    export async function login(
-      credentials: LoginCredentials
-    ): Promise<LoginResult> {
-      try {
-        const validationError = validateCredentials(credentials);
-        if (validationError) {
-          return { success: false, error: validationError };
-        }
-        
-        const user = await verifyUser(
-          credentials.email,
-          credentials.password
-        );
-        
-        if (!user) {
-          return { success: false, error: 'Invalid credentials' };
-        }
-        
-        const token = generateToken(user.id);
-        
-        return {
-          success: true,
-          user: { id: user.id, email: user.email },
-          token
-        };
-      } catch (error) {
-        console.error('Login error:', error);
-        return { success: false, error: 'An error occurred' };
-      }
-    }
-    ```
-    
-    [AI runs: npm test]
-    
-    ✅ All tests still pass after refactoring!
-    
-    ## Summary
-    
-    We've implemented login functionality using TDD:
-    - ✅ 5 tests covering happy path, errors, and edge cases
-    - ✅ Clean, testable code
-    - ✅ Proper error handling
-    - ✅ Type safety with TypeScript
-    
-    Next steps:
-    1. Add rate limiting tests
-    2. Add session management tests
-    3. Add logout functionality
-    
-    Should I continue with these?
-```
-
-### What Happened
-- ✅ Followed Red-Green-Refactor cycle
-- ✅ Wrote tests before implementation
-- ✅ Covered edge cases
-- ✅ Refactored with confidence
-- ✅ Maintained test coverage
-
----
-
-## Key Takeaways
-
-### What Makes These Examples Effective?
-
-1. **Skills ask clarifying questions** before jumping to solutions
-2. **Skills provide context-aware help** based on your project
-3. **Skills follow best practices** for their domain
-4. **Skills include complete examples** not just snippets
-5. **Skills explain the "why"** not just the "how"
-
-### How to Get Similar Results
-
-1. **Be specific** in your requests
-2. **Provide context** about your project
-3. **Answer questions** the skill asks
-4. **Review suggestions** before applying
-5. **Iterate** based on results
-
----
-
-## Try These Yourself!
-
-Pick a skill and try it with your own project:
-
-- **Planning:** `@brainstorming` or `@writing-plans`
-- **Development:** `@test-driven-development` or `@react-best-practices`
-- **Debugging:** `@systematic-debugging` or `@test-fixing`
-- **Integration:** `@stripe-integration` or `@firebase`
-- **Marketing:** `@copywriting` or `@seo-audit`
-
----
-
-**Want more examples?** Check individual skill folders for additional examples and use cases!
+1. **Build**: "Use `mcp-builder` to create a `verify-file` tool."
+2. **Instruct**: "Apply `prompt-engineering` patterns to the System Prompt so the agent always checks file paths."
+3. **Test**: "Run `agent-evaluation` to benchmark how often the agent fails to find the file."

docs/FAQ.md

@@ -0,0 +1,178 @@
+# ❓ Frequently Asked Questions (FAQ)
+
+**Got questions?** You're not alone! Here are answers to the most common questions about Antigravity Awesome Skills.
+
+---
+
+## 🎯 General Questions
+
+### What are "skills" exactly?
+
+Skills are specialized instruction files that teach AI assistants how to handle specific tasks. Think of them as expert knowledge modules that your AI can load on-demand.
+**Simple analogy:** Just like you might consult different experts (a lawyer, a doctor, a mechanic), these skills let your AI become an expert in different areas when you need them.
+
+### Do I need to install all 552+ skills?
+
+**No!** When you clone the repository, all skills are available, but your AI only loads them when you explicitly invoke them with `@skill-name`.
+It's like having a library - all books are there, but you only read the ones you need.
+**Pro Tip:** Use [Starter Packs](BUNDLES.md) to install only what matches your role.
+
+### Which AI tools work with these skills?
+
+- ✅ **Claude Code** (Anthropic CLI)
+- ✅ **Gemini CLI** (Google)
+- ✅ **Codex CLI** (OpenAI)
+- ✅ **Cursor** (AI IDE)
+- ✅ **Antigravity IDE**
+- ✅ **OpenCode**
+- ⚠️ **GitHub Copilot** (partial support via copy-paste)
+
+### Are these skills free to use?
+
+**Yes!** This repository is licensed under MIT License.
+
+- ✅ Free for personal use
+- ✅ Free for commercial use
+- ✅ You can modify them
+
+### Do skills work offline?
+
+The skill files themselves are stored locally on your computer, but your AI assistant needs an internet connection to function.
+
+---
+
+## 🔒 Security & Trust (V3 Update)
+
+### What do the Risk Labels mean?
+
+We classify skills so you know what you're running:
+
+- ⚪ **Safe (White/Blue)**: Read-only, planning, or benign skills.
+- 🔴 **Risk (Red)**: Skills that modify files (delete), use network scanners, or perform destructive actions. **Use with caution.**
+- 🟣 **Official (Purple)**: Maintained by trusted vendors (Anthropic, DeepMind, etc.).
+
+### Can these skills hack my computer?
+
+**No.** Skills are text files. However, they _instruct_ the AI to run commands. If a skill says "delete all files", a compliant AI might try to do it.
+_Always check the Risk label and review the code._
+
+---
+
+## 📦 Installation & Setup
+
+### Where should I install the skills?
+
+The universal path that works with most tools is `.agent/skills/`:
+
+```bash
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+**Tool-specific paths:**
+
+- Claude Code: `.claude/skills/`
+- Gemini CLI: `.gemini/skills/`
+- Cursor: `.cursor/skills/` or project root
+
+### Does this work with Windows?
+
+**Yes**, but some "Official" skills use **symlinks** which Windows handles poorly by default.
+Run git with:
+
+```bash
+git clone -c core.symlinks=true https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+Or enable "Developer Mode" in Windows Settings.
+
+### How do I update skills?
+
+Navigate to your skills directory and pull the latest changes:
+
+```bash
+cd .agent/skills
+git pull origin main
+```
+
+---
+
+## 🛠️ Using Skills
+
+### How do I invoke a skill?
+
+Use the `@` symbol followed by the skill name:
+
+```bash
+@brainstorming help me design a todo app
+```
+
+### Can I use multiple skills at once?
+
+**Yes!** You can invoke multiple skills:
+
+```bash
+@brainstorming help me design this, then use @writing-plans to create a task list.
+```
+
+### How do I know which skill to use?
+
+1. **Browse the catalog**: Check the [Skill Catalog](../CATALOG.md).
+2. **Search**: `ls skills/ | grep "keyword"`
+3. **Ask your AI**: "What skills do you have for testing?"
+
+---
+
+## 🏗️ Troubleshooting
+
+### My AI assistant doesn't recognize skills
+
+**Possible causes:**
+
+1. **Wrong installation path**: Check your tool's docs. Try `.agent/skills/`.
+2. **Restart Needed**: Restart your AI/IDE after installing.
+3. **Typos**: Did you type `@brain-storming` instead of `@brainstorming`?
+
+### A skill gives incorrect or outdated advice
+
+Please [Open an issue](https://github.com/sickn33/antigravity-awesome-skills/issues)!
+Include:
+
+- Which skill
+- What went wrong
+- What should happen instead
+
+---
+
+## 🤝 Contribution
+
+### I'm new to open source. Can I contribute?
+
+**Absolutely!** We welcome beginners.
+
+- Fix typos
+- Add examples
+- Improve docs
+  Check out [CONTRIBUTING.md](../CONTRIBUTING.md) for instructions.
+
+### My PR failed "Quality Bar" check. Why?
+
+V3 introduces automated quality control. Your skill might be missing:
+
+1. A valid `description`.
+2. Usage examples.
+   Run `python3 scripts/validate_skills.py` locally to check before you push.
+
+### Can I update an "Official" skill?
+
+**No.** Official skills (in `skills/official/`) are mirrored from vendors. Open an issue instead.
+
+---
+
+## 💡 Pro Tips
+
+- Start with `@brainstorming` before building anything new
+- Use `@systematic-debugging` when stuck on bugs
+- Try `@test-driven-development` for better code quality
+- Explore `@skill-creator` to make your own skills
+
+**Still confused?** [Open a discussion](https://github.com/sickn33/antigravity-awesome-skills/discussions) and we'll help you out! 🙌

docs/GETTING_STARTED.md

@@ -0,0 +1,108 @@
+# Getting Started with Antigravity Awesome Skills (V3)
+
+**New here? This guide will help you supercharge your AI Agent in 5 minutes.**
+
+---
+
+## 🤔 What Are "Skills"?
+
+AI Agents (like **Claude Code**, **Gemini**, **Cursor**) are smart, but they lack specific knowledge about your tools.
+**Skills** are specialized instruction manuals (markdown files) that teach your AI how to perform specific tasks perfectly, every time.
+
+**Analogy:** Your AI is a brilliant intern. **Skills** are the SOPs (Standard Operating Procedures) that make them a Senior Engineer.
+
+---
+
+## ⚡️ Quick Start: The "Starter Packs"
+
+Don't panic about the 560+ skills. You don't need them all at once.
+We have curated **Starter Packs** to get you running immediately.
+
+### 1. Install the Repo
+
+Copy the skills to your agent's folder:
+
+```bash
+# Universal Installation (works for most agents)
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+### 2. Pick Your Persona
+
+Find the bundle that matches your role (see [BUNDLES.md](BUNDLES.md)):
+
+| Persona               | Bundle Name    | What's Inside?                                    |
+| :-------------------- | :------------- | :------------------------------------------------ |
+| **Web Developer**     | `Web Wizard`   | React Patterns, Tailwind mastery, Frontend Design |
+| **Security Engineer** | `Hacker Pack`  | OWASP, Metasploit, Pentest Methodology            |
+| **Manager / PM**      | `Product Pack` | Brainstorming, Planning, SEO, Strategy            |
+| **Everything**        | `Essentials`   | Clean Code, Planning, Validation (The Basics)     |
+
+---
+
+## 🚀 How to Use a Skill
+
+Once installed, just talk to your AI naturally.
+
+### Example 1: Planning a Feature (**Essentials**)
+
+> "Use **@brainstorming** to help me design a new login flow."
+
+**What happens:** The AI loads the brainstorming skill, asks you structured questions, and produces a professional spec.
+
+### Example 2: Checking Your Code (**Web Wizard**)
+
+> "Run **@lint-and-validate** on this file and fix errors."
+
+**What happens:** The AI follows strict linting rules defined in the skill to clean your code.
+
+### Example 3: Security Audit (**Hacker Pack**)
+
+> "Use **@api-security-best-practices** to review my API endpoints."
+
+**What happens:** The AI audits your code against OWASP standards.
+
+---
+
+## 🔌 Supported Tools
+
+| Tool            | Status          | Path              |
+| :-------------- | :-------------- | :---------------- |
+| **Claude Code** | ✅ Full Support | `.claude/skills/` |
+| **Gemini CLI**  | ✅ Full Support | `.gemini/skills/` |
+| **Antigravity** | ✅ Native       | `.agent/skills/`  |
+| **Cursor**      | ✅ Native       | `.cursor/skills/` |
+| **Copilot**     | ⚠️ Text Only    | Manual copy-paste |
+
+---
+
+## 🛡️ Trust & Safety (New in V3)
+
+We classify skills so you know what you're running:
+
+- 🟣 **Official**: Maintained by Anthropic/Google/Vendors (High Trust).
+- 🔵 **Safe**: Community skills that are non-destructive (Read-only/Planning).
+- 🔴 **Risk**: Skills that modify systems or perform security tests (Authorized Use Only).
+
+_Check the [Skill Catalog](../CATALOG.md) for the full list._
+
+---
+
+## ❓ FAQ
+
+**Q: Do I need to install all 560 skills?**
+A: You clone the whole repo, but your AI only _reads_ the ones you ask for (or that are relevant). It's lightweight!
+
+**Q: Can I make my own skills?**
+A: Yes! Use the **@skill-creator** skill to build your own.
+
+**Q: Is this free?**
+A: Yes, MIT License. Open Source forever.
+
+---
+
+## ⏭️ Next Steps
+
+1. [Browse the Bundles](BUNDLES.md)
+2. [See Real-World Examples](EXAMPLES.md)
+3. [Contribute a Skill](../CONTRIBUTING.md)

docs/QUALITY_BAR.md

@@ -0,0 +1,64 @@
+# 🏆 Quality Bar & Validation Standards
+
+To transform **Antigravity Awesome Skills** from a collection of scripts into a trusted platform, every skill must meet a specific standard of quality and safety.
+
+## The "Validated" Badge ✅
+
+A skill earns the "Validated" badge only if it passes these **5 automated checks**:
+
+### 1. Metadata Integrity
+
+The `SKILL.md` frontmatter must be valid YAML and contain:
+
+- `name`: Kebab-case, matches folder name.
+- `description`: Under 200 chars, clear value prop.
+- `risk`: One of `[none, safe, critical, offensive]`.
+- `source`: URL to original source (or "self" if original).
+
+### 2. Clear Triggers ("When to use")
+
+The skill MUST have a section explicitly stating when to trigger it.
+
+- **Good**: "Use when the user asks to debug a React component."
+- **Bad**: "This skill helps you with code."
+
+### 3. Safety & Risk Classification
+
+Every skill must declare its risk level:
+
+- 🟢 **none**: Pure text/reasoning (e.g., Brainstorming).
+- 🔵 **safe**: Reads files, runs safe commands (e.g., Linter).
+- 🟠 **critical**: Modifies state, deletes files, pushes to prod (e.g., Git Push).
+- 🔴 **offensive**: Pentesting/Red Team tools. **MUST** have "Authorized Use Only" warning.
+
+### 4. Copy-Pasteable Examples
+
+At least one code block or interaction example that a user (or agent) can immediately use.
+
+### 5. Explicit Limitations
+
+A list of known edge cases or things the skill _cannot_ do.
+
+- _Example_: "Does not work on Windows without WSL."
+
+---
+
+## Support Levels
+
+We also categorize skills by who maintains them:
+
+| Level         | Badge | Meaning                                             |
+| :------------ | :---- | :-------------------------------------------------- |
+| **Official**  | 🟣    | Maintained by the core team. High reliability.      |
+| **Community** | ⚪    | Contributed by the ecosystem. Best effort support.  |
+| **Verified**  | ✨    | Community skill that has passed deep manual review. |
+
+---
+
+## How to Validate Your Skill
+
+Run the validator script before submitting a PR:
+
+```bash
+python3 scripts/validate_skills.py --strict
+```

docs/SECURITY_GUARDRAILS.md

@@ -0,0 +1,51 @@
+# 🛡️ Security Guardrails & Policy
+
+Antigravity Awesome Skills is a powerful toolkit. With great power comes great responsibility. This document defines the **Rules of Engagement** for all security and offensive capabilities in this repository.
+
+## 🔴 Offensive Skills Policy (The "Red Line")
+
+**What is an Offensive Skill?**
+Any skill designed to penetrate, exploit, disrupt, or simulate attacks against systems.
+_Examples: Pentesting, SQL Injection, Phishing Simulation, Red Teaming._
+
+### 1. The "Authorized Use Only" Disclaimer
+
+Every offensive skill **MUST** begin with this exact disclaimer in its `SKILL.md`:
+
+> **⚠️ AUTHORIZED USE ONLY**
+> This skill is for educational purposes or authorized security assessments only.
+> You must have explicit, written permission from the system owner before using this tool.
+> Misuse of this tool is illegal and strictly prohibited.
+
+### 2. Mandatory User Confirmation
+
+Offensive skills must **NEVER** run fully autonomously.
+
+- **Requirement**: The skill description/instructions must explicitly tell the agent to _ask for user confirmation_ before executing any exploit or attack command.
+- **Agent Instruction**: "Ask the user to verify the target URL/IP before running."
+
+### 3. Safe by Design
+
+- **No Weaponized Payloads**: Skills should not include active malware, ransomware, or non-educational exploits.
+- **Sandbox Recommended**: Instructions should recommend running in a contained environment (Docker/VM).
+
+---
+
+## 🔵 Defensive Skills Policy
+
+**What is a Defensive Skill?**
+Tools for hardening, auditing, monitoring, or protecting systems.
+_Examples: Linting, Log Analysis, Configuration Auditing._
+
+- **Data Privacy**: Defensive skills must not upload data to 3rd party servers without explicit user consent.
+- **Non-Destructive**: Audits should be read-only by default.
+
+---
+
+## ⚖️ Legal Disclaimer
+
+By using this repository, you agree that:
+
+1. You are responsible for your own actions.
+2. The authors and contributors are not liable for any damage caused by these tools.
+3. You will comply with all local, state, and federal laws regarding cybersecurity.

docs/SKILL_ANATOMY.md

@@ -31,6 +31,7 @@ skills/
 Every `SKILL.md` file has two main parts:
 
 ### 1. Frontmatter (Metadata)
+
 ### 2. Content (Instructions)
 
 Let's break down each part:
@@ -51,12 +52,14 @@ description: "Brief description of what this skill does"
 ### Required Fields
 
 #### `name`
+
 - **What it is:** The skill's identifier
 - **Format:** lowercase-with-hyphens
 - **Must match:** The folder name exactly
 - **Example:** `stripe-integration`
 
 #### `description`
+
 - **What it is:** One-sentence summary
 - **Format:** String in quotes
 - **Length:** Keep it under 150 characters
@@ -70,9 +73,9 @@ Some skills include additional metadata:
 ---
 name: my-skill-name
 description: "Brief description"
-version: "1.0.0"
-author: "Your Name"
-tags: ["react", "typescript", "testing"]
+risk: "safe" # safe | risk | official
+source: "community"
+tags: ["react", "typescript"]
 ---
 ```
 
@@ -85,13 +88,16 @@ After the frontmatter comes the actual skill content. Here's the recommended str
 ### Recommended Sections
 
 #### 1. Title (H1)
+
 ```markdown
 # Skill Title
 ```
+
 - Use a clear, descriptive title
 - Usually matches or expands on the skill name
 
 #### 2. Overview
+
 ```markdown
 ## Overview
 
@@ -100,6 +106,7 @@ A brief explanation of what this skill does and why it exists.
 ```
 
 #### 3. When to Use
+
 ```markdown
 ## When to Use This Skill
 
@@ -111,28 +118,34 @@ A brief explanation of what this skill does and why it exists.
 **Why this matters:** Helps the AI know when to activate this skill
 
 #### 4. Core Instructions
+
 ```markdown
 ## How It Works
 
 ### Step 1: [Action]
+
 Detailed instructions...
 
 ### Step 2: [Action]
+
 More instructions...
 ```
 
 **This is the heart of your skill** - clear, actionable steps
 
 #### 5. Examples
+
 ```markdown
 ## Examples
 
 ### Example 1: [Use Case]
+
 \`\`\`javascript
 // Example code
 \`\`\`
 
 ### Example 2: [Another Use Case]
+
 \`\`\`javascript
 // More code
 \`\`\`
@@ -141,6 +154,7 @@ More instructions...
 **Why examples matter:** They show the AI exactly what good output looks like
 
 #### 6. Best Practices
+
 ```markdown
 ## Best Practices
 
@@ -151,6 +165,7 @@ More instructions...
 ```
 
 #### 7. Common Pitfalls
+
 ```markdown
 ## Common Pitfalls
 
@@ -159,6 +174,7 @@ More instructions...
 ```
 
 #### 8. Related Skills
+
 ```markdown
 ## Related Skills
 
@@ -173,11 +189,13 @@ More instructions...
 ### Use Clear, Direct Language
 
 **❌ Bad:**
+
 ```markdown
 You might want to consider possibly checking if the user has authentication.
 ```
 
 **✅ Good:**
+
 ```markdown
 Check if the user is authenticated before proceeding.
 ```
@@ -185,11 +203,13 @@ Check if the user is authenticated before proceeding.
 ### Use Action Verbs
 
 **❌ Bad:**
+
 ```markdown
 The file should be created...
 ```
 
 **✅ Good:**
+
 ```markdown
 Create the file...
 ```
@@ -197,11 +217,13 @@ Create the file...
 ### Be Specific
 
 **❌ Bad:**
+
 ```markdown
 Set up the database properly.
 ```
 
 **✅ Good:**
+
 ```markdown
 1. Create a PostgreSQL database
 2. Run migrations: `npm run migrate`
@@ -224,6 +246,7 @@ scripts/
 ```
 
 **Reference them in SKILL.md:**
+
 ```markdown
 Run the setup script:
 \`\`\`bash
@@ -256,6 +279,7 @@ templates/
 ```
 
 **Reference in SKILL.md:**
+
 ```markdown
 Use this template as a starting point:
 \`\`\`typescript
@@ -279,16 +303,19 @@ references/
 ## Skill Size Guidelines
 
 ### Minimum Viable Skill
+
 - **Frontmatter:** name + description
 - **Content:** 100-200 words
 - **Sections:** Overview + Instructions
 
 ### Standard Skill
+
 - **Frontmatter:** name + description
 - **Content:** 300-800 words
 - **Sections:** Overview + When to Use + Instructions + Examples
 
 ### Comprehensive Skill
+
 - **Frontmatter:** name + description + optional fields
 - **Content:** 800-2000 words
 - **Sections:** All recommended sections
@@ -303,7 +330,9 @@ references/
 ### Use Markdown Effectively
 
 #### Code Blocks
+
 Always specify the language:
+
 ```markdown
 \`\`\`javascript
 const example = "code";
@@ -311,7 +340,9 @@ const example = "code";
 ```
 
 #### Lists
+
 Use consistent formatting:
+
 ```markdown
 - Item 1
 - Item 2
@@ -320,11 +351,13 @@ Use consistent formatting:
 ```
 
 #### Emphasis
+
 - **Bold** for important terms: `**important**`
-- *Italic* for emphasis: `*emphasis*`
+- _Italic_ for emphasis: `*emphasis*`
 - `Code` for commands/code: `` `code` ``
 
 #### Links
+
 ```markdown
 [Link text](https://example.com)
 ```
@@ -336,24 +369,28 @@ Use consistent formatting:
 Before finalizing your skill:
 
 ### Content Quality
+
 - [ ] Instructions are clear and actionable
 - [ ] Examples are realistic and helpful
 - [ ] No typos or grammar errors
 - [ ] Technical accuracy verified
 
 ### Structure
+
 - [ ] Frontmatter is valid YAML
 - [ ] Name matches folder name
 - [ ] Sections are logically organized
 - [ ] Headings follow hierarchy (H1 → H2 → H3)
 
 ### Completeness
+
 - [ ] Overview explains the "why"
 - [ ] Instructions explain the "how"
 - [ ] Examples show the "what"
 - [ ] Edge cases are addressed
 
 ### Usability
+
 - [ ] A beginner could follow this
 - [ ] An expert would find it useful
 - [ ] The AI can parse it correctly
@@ -373,6 +410,7 @@ description: "You MUST use this before any creative work..."
 ```
 
 **Analysis:**
+
 - ✅ Clear name
 - ✅ Strong description with urgency ("MUST use")
 - ✅ Explains when to use it
@@ -381,10 +419,12 @@ description: "You MUST use this before any creative work..."
 # Brainstorming Ideas Into Designs
 
 ## Overview
+
 Help turn ideas into fully formed designs...
 ```
 
 **Analysis:**
+
 - ✅ Clear title
 - ✅ Concise overview
 - ✅ Explains the value proposition
@@ -393,11 +433,13 @@ Help turn ideas into fully formed designs...
 ## The Process
 
 **Understanding the idea:**
+
 - Check out the current project state first
 - Ask questions one at a time
 ```
 
 **Analysis:**
+
 - ✅ Broken into clear phases
 - ✅ Specific, actionable steps
 - ✅ Easy to follow
@@ -412,10 +454,12 @@ Help turn ideas into fully formed designs...
 ## Instructions
 
 If the user is working with React:
+
 - Use functional components
 - Prefer hooks over class components
 
 If the user is working with Vue:
+
 - Use Composition API
 - Follow Vue 3 patterns
 ```
@@ -424,9 +468,11 @@ If the user is working with Vue:
 
 ```markdown
 ## Basic Usage
+
 [Simple instructions for common cases]
 
 ## Advanced Usage
+
 [Complex patterns for power users]
 ```
 
@@ -447,15 +493,18 @@ If the user is working with Vue:
 How to know if your skill is good:
 
 ### Clarity Test
+
 - Can someone unfamiliar with the topic follow it?
 - Are there any ambiguous instructions?
 
 ### Completeness Test
+
 - Does it cover the happy path?
 - Does it handle edge cases?
 - Are error scenarios addressed?
 
 ### Usefulness Test
+
 - Does it solve a real problem?
 - Would you use this yourself?
 - Does it save time or improve quality?
@@ -467,11 +516,13 @@ How to know if your skill is good:
 ### Study These Examples
 
 **For Beginners:**
+
 - `skills/brainstorming/SKILL.md` - Clear structure
 - `skills/git-pushing/SKILL.md` - Simple and focused
 - `skills/copywriting/SKILL.md` - Good examples
 
 **For Advanced:**
+
 - `skills/systematic-debugging/SKILL.md` - Comprehensive
 - `skills/react-best-practices/SKILL.md` - Multiple files
 - `skills/loki-mode/SKILL.md` - Complex workflows
@@ -491,22 +542,28 @@ How to know if your skill is good:
 ## Common Mistakes to Avoid
 
 ### ❌ Mistake 1: Too Vague
+
 ```markdown
 ## Instructions
+
 Make the code better.
 ```
 
 **✅ Fix:**
+
 ```markdown
 ## Instructions
+
 1. Extract repeated logic into functions
 2. Add error handling for edge cases
 3. Write unit tests for core functionality
 ```
 
 ### ❌ Mistake 2: Too Complex
+
 ```markdown
 ## Instructions
+
 [5000 words of dense technical jargon]
 ```
 
@@ -514,8 +571,10 @@ Make the code better.
 Break into multiple skills or use progressive disclosure
 
 ### ❌ Mistake 3: No Examples
+
 ```markdown
 ## Instructions
+
 [Instructions without any code examples]
 ```
 
@@ -523,6 +582,7 @@ Break into multiple skills or use progressive disclosure
 Add at least 2-3 realistic examples
 
 ### ❌ Mistake 4: Outdated Information
+
 ```markdown
 Use React class components...
 ```

docs/SOURCES.md

@@ -0,0 +1,21 @@
+# 📜 Sources & Attributions
+
+We believe in giving credit where credit is due.
+If you recognize your work here and it is not properly attributed, please open an Issue.
+
+| Skill / Category            | Original Source                                        | License        | Notes                         |
+| :-------------------------- | :----------------------------------------------------- | :------------- | :---------------------------- |
+| `cloud-penetration-testing` | [HackTricks](https://book.hacktricks.xyz/)             | MIT / CC-BY-SA | Adapted for agentic use.      |
+| `active-directory-attacks`  | [HackTricks](https://book.hacktricks.xyz/)             | MIT / CC-BY-SA | Adapted for agentic use.      |
+| `owasp-top-10`              | [OWASP](https://owasp.org/)                            | CC-BY-SA       | Methodology adapted.          |
+| `burp-suite-testing`        | [PortSwigger](https://portswigger.net/burp)            | N/A            | Usage guide only (no binary). |
+| `crewai`                    | [CrewAI](https://github.com/joaomdmoura/crewAI)        | MIT            | Framework guides.             |
+| `langgraph`                 | [LangGraph](https://github.com/langchain-ai/langgraph) | MIT            | Framework guides.             |
+| `react-patterns`            | [React Docs](https://react.dev/)                       | CC-BY          | Official patterns.            |
+| **All Official Skills**     | [Anthropic / Google / OpenAI]                          | Proprietary    | Usage encouraged by vendors.  |
+
+## License Policy
+
+- **Code**: All original code in this repository is **MIT**.
+- **Content**: Documentation is **CC-BY-4.0**.
+- **Third Party**: We respect the upstream licenses. If an imported skill is GPL, it will be marked clearly or excluded (we aim for MIT/Apache compatibility).

docs/VISUAL_GUIDE.md

@@ -31,10 +31,9 @@
 antigravity-awesome-skills/
 │
 ├── 📄 README.md                    ← Overview & skill list
-├── 📄 GETTING_STARTED.md           ← Start here! (NEW)
-├── 📄 CONTRIBUTING.md        ← How to contribute (NEW)
+├── 📄 CONTRIBUTING.md              ← How to contribute
 │
-├── 📁 skills/                      ← All 179 skills live here
+├── 📁 skills/                      ← All 250+ skills live here
 │   │
 │   ├── 📁 brainstorming/
 │   │   └── 📄 SKILL.md             ← Skill definition
@@ -43,20 +42,22 @@ antigravity-awesome-skills/
 │   │   ├── 📄 SKILL.md
 │   │   └── 📁 examples/            ← Optional extras
 │   │
-│   ├── 📁 react-best-practices/
-│   │   ├── 📄 SKILL.md
-│   │   ├── 📁 rules/
-│   │   └── 📄 README.md
-│   │
-│   └── ... (176 more skills)
+│   └── ... (250+ more skills)
 │
 ├── 📁 scripts/                     ← Validation & management
-│   ├── validate_skills.py
-│   └── generate_index.py
+│   ├── validate_skills.py          ← Quality Bar Enforcer
+│   └── generate_index.py           ← Registry Generator
 │
-└── 📁 docs/                        ← Documentation (NEW)
+├── 📁 .github/
+│   └── 📄 MAINTENANCE.md           ← Maintainers Guide
+│
+└── 📁 docs/                        ← Documentation
+    ├── 📄 GETTING_STARTED.md       ← Start here! (NEW)
+    ├── 📄 FAQ.md                   ← Troubleshooting
+    ├── 📄 BUNDLES.md               ← Starter Packs (NEW)
+    ├── 📄 QUALITY_BAR.md           ← Quality Standards
     ├── 📄 SKILL_ANATOMY.md         ← How skills work
-    └── 📄 VISUAL_GUIDE.md    ← This file!
+    └── 📄 VISUAL_GUIDE.md          ← This file!
 ```
 
 ---
@@ -95,7 +96,7 @@ antigravity-awesome-skills/
 
 ```
                     ┌─────────────────────────┐
-                    │  179 AWESOME SKILLS     │
+                    │   250+ AWESOME SKILLS   │
                     └────────────┬────────────┘
                                  │
         ┌────────────────────────┼────────────────────────┐
@@ -129,7 +130,7 @@ antigravity-awesome-skills/
 
 ## Skill File Anatomy (Visual)
 
-```
+````
 ┌─────────────────────────────────────────────────────────┐
 │ SKILL.md                                                │
 ├─────────────────────────────────────────────────────────┤
@@ -167,13 +168,14 @@ antigravity-awesome-skills/
 │  └───────────────────────────────────────────────┘     │
 │                                                         │
 └─────────────────────────────────────────────────────────┘
-```
+````
 
 ---
 
 ## Installation (Visual Steps)
 
 ### Step 1: Clone the Repository
+
 ```
 ┌─────────────────────────────────────────┐
 │ Terminal                                │
@@ -188,6 +190,7 @@ antigravity-awesome-skills/
 ```
 
 ### Step 2: Verify Installation
+
 ```
 ┌─────────────────────────────────────────┐
 │ File Explorer                           │
@@ -202,6 +205,7 @@ antigravity-awesome-skills/
 ```
 
 ### Step 3: Use a Skill
+
 ```
 ┌─────────────────────────────────────────┐
 │ AI Assistant Chat                       │
@@ -271,16 +275,19 @@ antigravity-awesome-skills/
 ## Finding Skills (Visual Guide)
 
 ### Method 1: Browse by Category
+
 ```
 README.md → Scroll to "Full Skill Registry" → Find category → Pick skill
 ```
 
 ### Method 2: Search by Keyword
+
 ```
 Terminal → ls skills/ | grep "keyword" → See matching skills
 ```
 
 ### Method 3: Use the Index
+
 ```
 Open skills_index.json → Search for keyword → Find skill path
 ```
@@ -449,7 +456,7 @@ START HERE
 │  5. Submit PR                                               │
 │                                                             │
 │  🆘 HELP                                                    │
-│  • GETTING_STARTED.md - Basics                              │
+│  • docs/GETTING_STARTED.md - Basics                         │
 │  • CONTRIBUTING.md - How to contribute                │
 │  • SKILL_ANATOMY.md - Deep dive                             │
 │  • GitHub Issues - Ask questions                            │
@@ -465,19 +472,19 @@ START HERE
 Day 1: Install skills
   │
   └─→ "Wow, @brainstorming helped me design my app!"
-  
+
 Day 3: Use 5 different skills
   │
   └─→ "These skills save me so much time!"
-  
+
 Week 1: Create first skill
   │
   └─→ "I shared my expertise as a skill!"
-  
+
 Week 2: Skill gets merged
   │
   └─→ "My skill is helping others! 🎉"
-  
+
 Month 1: Regular contributor
   │
   └─→ "I've contributed 5 skills and improved docs!"
@@ -497,7 +504,8 @@ Month 1: Regular contributor
 ---
 
 **Visual learner?** This guide should help! Still have questions? Check out:
-- [GETTING_STARTED.md](../GETTING_STARTED.md) - Text-based intro
+
+- [GETTING_STARTED.md](GETTING_STARTED.md) - Text-based intro
 - [SKILL_ANATOMY.md](SKILL_ANATOMY.md) - Detailed breakdown
 - [CONTRIBUTING.md](../CONTRIBUTING.md) - How to contribute
 

docs/vietnamese/BUNDLES.vi.md

@@ -0,0 +1,124 @@
+# 📦 Gói Kỹ năng Antigravity (Skill Bundles)
+
+Bạn không biết bắt đầu từ đâu? Hãy chọn một gói dưới đây để sỡ hữu bộ kỹ năng được tuyển chọn phù hợp cho vai trò của bạn.
+
+## 🚀 Gói Khởi đầu "Thiết yếu" (Essentials)
+
+_Dành cho tất cả mọi người. Hãy cài đặt những kỹ năng này đầu tiên._
+
+- `concise-planning`: Luôn bắt đầu bằng một kế hoạch.
+- `lint-and-validate`: Giữ code sạch sẽ một cách tự động.
+- `git-pushing`: Lưu công việc của bạn một cách an toàn.
+- `kaizen`: Tư duy cải tiến liên tục.
+
+## 🛡️ Gói "Kỹ sư Bảo mật" (Security Engineer)
+
+_Dành cho pentesting, kiểm tra (auditing) và tăng cường bảo mật (hardening)._
+
+- `ethical-hacking-methodology`: "Kinh thánh" về hacking đạo đức.
+- `burp-suite-testing`: Quét lỗ hổng web.
+- `owasp-top-10`: Kiểm tra các lỗi phổ biến nhất.
+- `linux-privilege-escalation`: Đánh giá bảo mật Linux nâng cao.
+- `cloud-penetration-testing`: Bảo mật AWS/Azure/GCP.
+
+## 🌐 Gói "Phù thủy Web" (Web Wizard)
+
+_Để xây dựng các ứng dụng web hiện đại, hiệu suất cao._
+
+- `frontend-design`: Hướng dẫn về UI và thẩm mỹ.
+- `react-patterns`: Các thực hành tốt nhất cho React (nếu có sẵn).
+- `tailwind-patterns`: Siêu năng lực tạo kiểu (styling).
+- `form-cro`: Tối ưu hóa các biểu mẫu để tăng tỷ lệ chuyển đổi.
+- `seo-audit`: Giúp trang web của bạn xuất hiện trên Google.
+
+## 🤖 Gói "Kiến trúc sư Agent" (Agent Architect)
+
+_Để xây dựng các hệ thống AI._
+
+- `agent-evaluation`: Kiểm tra các trợ lý AI (agents) của bạn.
+- `langgraph`: Xây dựng quy trình làm việc agent có trạng thái (stateful).
+- `mcp-builder`: Tự tạo các công cụ của riêng bạn.
+- `prompt-engineering`: Làm chủ nghệ thuật giao tiếp với LLM.
+
+## 🎮 Gói "Lập trình viên Game Độc lập" (Indie Game Dev)
+
+_Đế xây dựng trò chơi với sự trợ giúp của AI._
+
+- `game-development/game-design`: Cơ chế và vòng lặp trò chơi.
+- `game-development/2d-games`: Sprite và vật lý 2D.
+- `game-development/3d-games`: Mô hình 3D và shader.
+- `game-development/unity-csharp`: Làm chủ lập trình C#.
+- `algorithmic-art`: Tạo tài nguyên game (assets) bằng code.
+
+## 🐍 Gói "Chuyên gia Python" (Python Pro)
+
+_Dành cho những người làm backend và các nhà khoa học dữ liệu._
+
+- `python-patterns`: Viết code Python chuẩn mực (idiomatic).
+- `poetry-manager`: Quản lý phụ thuộc (dependencies) hiệu quả.
+- `pytest-mastery`: Các framework kiểm thử.
+- `fastapi-expert`: Xây dựng API hiệu suất cao.
+- `django-guide`: Framework đầy đủ tính năng "battery-included".
+
+## 🦄 Gói "Người sáng lập Startup" (Startup Founder)
+
+_Để xây dựng sản phẩm, không chỉ là viết code._
+
+- `product-requirements-doc`: Định nghĩa những gì cần xây dựng.
+- `competitor-analysis`: Biết rõ đối thủ của bạn là ai.
+- `pitch-deck-creator`: Gọi vốn (hoặc chỉ để giải thích ý tưởng của bạn).
+- `landing-page-copy`: Viết nội dung bán hàng hiệu quả.
+- `stripe-integration`: Phương thức thanh toán.
+
+## 🌧️ Gói "DevOps & Cloud"
+
+_Dành cho hạ tầng và mở rộng hệ thống._
+
+- `docker-expert`: Làm chủ container và build đa giai đoạn.
+- `aws-serverless`: Sử dụng serverless trên AWS (Lambda, DynamoDB).
+- `environment-setup-guide`: Chuẩn hóa cho các đội ngũ.
+- `deployment-procedures`: Chiến lược triển khai an toàn.
+- `bash-linux`: Làm chủ dòng lệnh Terminal.
+
+## 📊 Gói "Dữ liệu & Phân tích" (Data & Analytics)
+
+_Để hiểu rõ các con số._
+
+- `analytics-tracking`: Thiết lập GA4/PostHog chính xác.
+- `d3-viz`: Các hình ảnh hóa dữ liệu tùy chỉnh đẹp mắt.
+- `sql-mastery`: Viết truy vấn tốt hơn (Skill cộng đồng).
+- `ab-test-setup`: Học hỏi từ thực nghiệm đã xác thực.
+
+## 🎨 Gói "Giám đốc Sáng tạo" (Creative Director)
+
+_Dành cho hình ảnh, nội dung và thương hiệu._
+
+- `canvas-design`: Tạo poster và sơ đồ.
+- `frontend-design`: Thẩm mỹ UI.
+- `content-creator`: Các bài blog tối ưu hóa SEO.
+- `copy-editing`: Trau chuốt nội dung văn bản.
+- `algorithmic-art`: Các tác phẩm nghệ thuật tạo bằng code.
+
+## 🐞 Gói "QA & Kiểm thử" (QA & Testing)
+
+_Để phát hiện lỗi trước khi người dùng thấy._
+
+- `test-driven-development`: Red, Green, Refactor.
+- `systematic-debugging`: "Sherlock Holmes" trong thế giới code.
+- `browser-automation`: Kiểm thử đầu cuối (E2E) với Playwright.
+- `ab-test-setup`: Các thử nghiệm đã được xác thực.
+- `code-review-checklist`: Phát hiện lỗi trong các Pull Request.
+
+## 🖌️ Gói "Thiết kế Web" (Web Designer)
+
+_Để tạo ra những trải nghiệm hoàn hảo đến từng pixel._
+
+- `ui-ux-pro-max`: Hệ thống thiết kế/tokens cao cấp.
+- `frontend-design`: Nền tảng của thẩm mỹ.
+- `3d-web-experience`: Ma thuật của Three.js & R3F.
+- `canvas-design`: Hình ảnh tĩnh/poster.
+- `responsive-layout`: Các nguyên tắc ưu tiên di động (Mobile-first).
+
+---
+
+_Để sử dụng một gói kỹ năng, chỉ cần copy tên các skill vào thư mục `.agent/skills` của bạn hoặc yêu cầu trợ lý AI sử dụng chúng._

docs/vietnamese/CONTRIBUTING.vi.md

@@ -0,0 +1,236 @@
+# 🤝 Hướng dẫn Đóng góp - Phiên bản V3 Enterprise
+
+**Cảm ơn bạn đã muốn làm cho repository này trở nên tốt hơn!** Hướng dẫn này sẽ chỉ cho bạn chính xác cách thức đóng góp, ngay cả khi bạn là người mới đối với mã nguồn mở.  
+Với phiên bản V3, chúng tôi đã nâng cao các tiêu chuẩn về chất lượng. Vui lòng đọc kỹ **Tiêu chuẩn Chất lượng mới** bên dưới.
+
+---
+
+## 🧐 "Quy chuẩn Chất lượng" (Quality Bar - Tiêu chuẩn V3)
+
+**Quan trọng đối với các skill mới:** Mỗi skill được gửi đi phải vượt qua **5 bước Kiểm tra Chất lượng** (xem `docs/vietnamese/QUALITY_BAR.md` để biết chi tiết):
+
+1.  **Siêu dữ liệu (Metadata)**: Phần Frontmatter chính xác (`name`, `description`).
+2.  **An toàn (Safety)**: Không chứa các lệnh gây hại mà không có nhãn rủi ro ("Risk").
+3.  **Rõ ràng (Clarity)**: Có phần "Khi nào nên dùng" (When to use) rõ ràng.
+4.  **Ví dụ (Examples)**: Ít nhất một ví dụ sử dụng có thể sao chép và dùng được ngay.
+5.  **Hành động (Actions)**: Phải định nghĩa các bước hành động cụ thể cho AI, không chỉ là các "ý nghĩ".
+
+---
+
+## Các Cách để Đóng góp
+
+Bạn không cần phải là một chuyên gia! Dưới đây là những cách mà bất kỳ ai cũng có thể giúp đỡ:
+
+### 1. Cải thiện Tài liệu (Dễ nhất!)
+
+- Sửa lỗi chính tả hoặc ngữ pháp.
+- Làm cho các giải thích trở nên rõ ràng hơn.
+- Thêm ví dụ vào các kỹ năng hiện có.
+- Dịch tài liệu sang các ngôn ngữ khác.
+
+### 2. Báo cáo Vấn đề (Issues)
+
+- Thấy điều gì đó khó hiểu? Hãy cho chúng tôi biết!
+- Kỹ năng không hoạt động? Hãy báo cho chúng tôi!
+- Bạn có đề xuất? Chúng tôi luôn sẵn sàng lắng nghe!
+
+### 3. Tạo Kỹ năng (Skill) mới
+
+- Chia sẻ chuyên môn của bạn dưới dạng một kỹ năng.
+- Lấp đầy các khoảng trống trong bộ sưu tập hiện tại.
+- Cải thiện các kỹ năng sẵn có.
+
+### 4. Kiểm thử và Xác thực
+
+- Thử nghiệm các kỹ năng và báo cáo những gì hoạt động hoặc không hoạt động.
+- Kiểm tra trên các công cụ AI khác nhau.
+- Đề xuất các cải tiến.
+
+---
+
+## Cách Tạo một Kỹ năng mới
+
+### Hướng dẫn Từng bước
+
+#### Bước 1: Chọn Chủ đề cho Kỹ năng của bạn
+
+Hãy tự hỏi: "Tôi ước trợ lý AI của mình hiểu rõ hơn về điều gì?".  
+Ví dụ: "Tôi giỏi về Docker, tôi sẽ tạo một kỹ năng về Docker".
+
+#### Bước 2: Tạo Cấu trúc Thư mục
+
+Các kỹ năng nằm trong thư mục `skills/`. Sử dụng định dạng `kebab-case` cho tên thư mục.
+
+```bash
+# Di chuyển đến thư mục skills
+cd skills/
+
+# Tạo thư mục cho skill của bạn
+mkdir my-awesome-skill
+cd my-awesome-skill
+
+# Tạo file SKILL.md
+touch SKILL.md
+```
+
+#### Bước 3: Viết Nội dung cho SKILL.md
+
+Mỗi kỹ năng đều cần cấu trúc cơ bản này. **Hãy sao chép mẫu dưới đây:**
+
+```markdown
+---
+name: my-awesome-skill
+description: "Mô tả ngắn gọn về chức năng của skill này"
+---
+
+# Tiêu đề Skill
+
+## Tổng quan
+
+Giải thích skill này làm gì và khi nào nên sử dụng nó.
+
+## Khi nào nên sử dụng Skill này
+
+- Sử dụng khi [tình huống 1]
+- Sử dụng khi [tình huống 2]
+
+## Cách hoạt động
+
+Hướng dẫn chi tiết từng bước cho AI...
+
+## Ví dụ
+
+### Ví dụ 1
+
+\`\`\`
+code ví dụ ở đây
+\`\`\`
+
+## Thực hành tốt nhất
+
+- ✅ Nên làm điều này
+- ❌ Không nên làm điều này
+```
+
+#### Bước 4: Xác thực (BƯỚC V3 QUAN TRỌNG)
+
+Chạy script xác thực (validation) tại máy của bạn. **Chúng tôi sẽ không chấp nhận các Pull Request (PR) thất bại ở bước kiểm tra này.**
+
+```bash
+# Chế độ nhẹ (chỉ cảnh báo)
+python3 scripts/validate_skills.py
+
+# Chế độ nghiêm ngặt (chế độ mà hệ thống CI sẽ chạy)
+python3 scripts/validate_skills.py --strict
+```
+
+Bước này sẽ kiểm tra:
+
+- ✅ File `SKILL.md` có tồn tại hay không.
+- ✅ Phần Frontmatter có chính xác không.
+- ✅ Tên (Name) có khớp với tên thư mục không.
+- ✅ Có vượt qua các kiểm tra của Quality Bar không.
+
+#### Bước 5: Gửi Kỹ năng của bạn
+
+```bash
+git add skills/my-awesome-skill/
+git commit -m "feat: add my-awesome-skill"
+git push origin my-branch
+```
+
+---
+
+## Bản mẫu (Template) Kỹ năng (Copy & Paste)
+
+Tiết kiệm thời gian! Hãy sao chép bản mẫu này:
+
+```markdown
+---
+name: your-skill-name
+description: "Mô tả trong một câu về chức năng của skill và khi nào cần dùng"
+---
+
+# Tên Kỹ năng của bạn
+
+## Tổng quan
+
+[2-3 câu giải thích skill này làm gì]
+
+## Khi nào nên sử dụng Skill này
+
+- Sử dụng khi bạn cần [tình huống 1]
+- Sử dụng khi bạn muốn [tình huống 2]
+
+## Hướng dẫn Từng bước
+
+### 1. [Tên Bước đầu tiên]
+
+[Hướng dẫn chi tiết]
+
+## Ví dụ
+
+### Ví dụ 1: [Tên Trường hợp sử dụng]
+
+\`\`\`language
+// Code ví dụ ở đây
+\`\`\`
+
+## Thực hành tốt nhất
+
+- ✅ **Nên:** [Thực hành tốt]
+- ❌ **Không nên:** [Điều cần tránh]
+
+## Xử lý Sự cố
+
+**Vấn đề:** [Lỗi thường gặp]
+**Giải pháp:** [Cách khắc phục]
+```
+
+---
+
+## Hướng dẫn về Thông điệp Commit (Commit Message)
+
+Sử dụng các tiền tố sau:
+
+- `feat:` - Kỹ năng mới hoặc tính năng lớn.
+- `docs:` - Cải thiện tài liệu hướng dẫn.
+- `fix:` - Sửa lỗi.
+- `refactor:` - Cải thiện code mà không thay đổi chức năng.
+- `test:` - Thêm hoặc cập nhật các bài kiểm tra.
+- `chore:` - Các tác vụ bảo trì.
+
+**Ví dụ:**
+
+```
+feat: add kubernetes-deployment skill
+docs: improve getting started guide
+fix: correct typo in stripe-integration skill
+```
+
+---
+
+## Tài liệu Học tập
+
+### Bạn mới sử dụng Git/GitHub?
+
+- [Hướng dẫn Hello World của GitHub](https://guides.github.com/activities/hello-world/)
+- [Cơ bản về Git](https://git-scm.com/book/en/v2/Getting-Started-Git-Basics)
+
+### Bạn mới sử dụng Markdown?
+
+- [Hướng dẫn Markdown](https://www.markdownguide.org/basic-syntax/)
+
+---
+
+## Quy tắc Ứng xử (Code of Conduct)
+
+- Luôn tôn trọng và hòa nhập.
+- Chào đón những người mới.
+- Tập trung vào các phản hồi mang tính xây dựng.
+- **Không chứa nội dung gây hại**: Xem `docs/vietnamese/SECURITY_GUARDRAILS.md`.
+
+---
+
+**Cảm ơn bạn đã làm cho dự án này trở nên tốt đẹp hơn cho mọi người!**  
+Mọi sự đóng góp, dù nhỏ đến đâu, đều tạo nên sự khác biệt. Dù bạn sửa một lỗi chính tả, cải thiện một câu văn, hay tạo ra một kỹ năng hoàn toàn mới - bạn đang giúp đỡ hàng ngàn lập trình viên khác!

docs/vietnamese/EXAMPLES.vi.md

@@ -0,0 +1,56 @@
+# 🧪 Ví dụ Thực tế ("Sổ tay Nấu ăn Antigravity")
+
+Các kỹ năng (skills) vốn dĩ đã mạnh mẽ khi đứng riêng lẻ, nhưng chúng sẽ trở nên không thể ngăn cản khi được kết hợp lại với nhau.  
+Dưới đây là ba tình huống phổ biến và cách giải quyết chúng bằng cách sử dụng repository này.
+
+## 🥘 Công thức 1: "Kiểm tra Code cũ (Legacy Code Audit)"
+
+_Tình huống: Bạn vừa tiếp nhận một repository Node.js 5 năm tuổi đang rất hỗn loạn. Bạn cần sửa nó một cách an toàn._
+
+**Các Skill sử dụng:**
+
+1. `concise-planning` (Để lập bản đồ cho sự hỗn loạn)
+2. `lint-and-validate` (Để tìm ra lỗi)
+3. `security-audit` (Để tìm ra lỗ hổng bảo mật)
+
+**Quy trình làm việc (Workflow):**
+
+1. **Lập kế hoạch**: "Agent, hãy dùng `concise-planning` để tạo một danh sách kiểm tra (checklist) cho việc tái cấu trúc (refactoring) file `src/legacy-api.js`."
+2. **Kiểm tra**: "Chạy `security-audit` trên file `package.json` để tìm các thư viện phụ thuộc có lỗ hổng bảo mật."
+3. **Sửa lỗi**: "Sử dụng các quy tắc của `lint-and-validate` để tự động sửa các lỗi định dạng trong thư mục `src/`."
+
+---
+
+## 🥘 Công thức 2: "Ứng dụng Web hiện đại"
+
+_Tình huống: Bạn cần xây dựng một trang Landing Page hiệu suất cao trong vòng 2 giờ._
+
+**Các Skill sử dụng:**
+
+1. `frontend-design` (Để đảm bảo tính thẩm mỹ)
+2. `react-patterns` (Để xây dựng cấu trúc)
+3. `tailwind-mastery` (Để tăng tốc độ triển khai)
+
+**Quy trình làm việc (Workflow):**
+
+1. **Thiết kế**: "Hãy sử dụng `frontend-design` để tạo bảng màu và kiểu chữ cho một 'Quán cà phê phong cách Cyberpunk'."
+2. **Khởi tạo**: "Khởi tạo một dự án Vite. Sau đó áp dụng `react-patterns` để tạo component 'Hero'."
+3. **Định dạng kiểu dáng**: "Sử dụng `tailwind-mastery` để làm cho các nút bấm có hiệu ứng glassmorphic (hiệu ứng kính mờ) và phản hồi tốt trên nhiều thiết bị (responsive)."
+
+---
+
+## 🥘 Công thức 3: "Kiến trúc sư Agent"
+
+_Tình huống: Bạn muốn xây dựng một trợ lý AI (agent) tùy chỉnh có khả năng tự xác minh mã code của chính nó._
+
+**Các Skill sử dụng:**
+
+1. `mcp-builder` (Để xây dựng công cụ)
+2. `agent-evaluation` (Để kiểm tra độ tin cậy)
+3. `prompt-engineering` (Để trau chuốt các hướng dẫn)
+
+**Quy trình làm việc (Workflow):**
+
+1. **Xây dựng**: "Sử dụng `mcp-builder` để tạo một công cụ `verify-file`."
+2. **Hướng dẫn**: "Áp dụng các mẫu `prompt-engineering` vào System Prompt để agent luôn kiểm tra lại đường dẫn file."
+3. **Kiểm tra**: "Chạy `agent-evaluation` để đo lường tần suất agent thất bại trong việc tìm file."

docs/vietnamese/FAQ.vi.md

@@ -0,0 +1,178 @@
+# ❓ Câu hỏi thường gặp (FAQ)
+
+**Bạn có thắc mắc?** Bạn không hề cô đơn! Dưới đây là câu trả lời cho những câu hỏi thường gặp nhất về Antigravity Awesome Skills.
+
+---
+
+## 🎯 Câu hỏi Chung
+
+### "Skills" (kỹ năng) chính xác là gì?
+
+Skills là các tệp hướng dẫn chuyên biệt dạy cho các trợ lý AI cách xử lý những tác vụ cụ thể. Hãy coi chúng như những mô-đun kiến thức chuyên gia mà AI của bạn có thể tải khi cần.  
+**Một so sánh đơn giản:** Giống như việc bạn tham khảo ý kiến của các chuyên gia khác nhau (luật sư, bác sĩ, thợ máy), những kỹ năng này giúp AI của bạn trở thành chuyên gia trong các lĩnh vực khác nhau khi bạn cần.
+
+### Tôi có cần phải cài đặt tất cả hơn 552 skills không?
+
+**Không!** Khi bạn clone (tải bản sao) repository này, tất cả các kỹ năng đều có sẵn, nhưng AI của bạn chỉ tải chúng khi bạn yêu cầu rõ ràng bằng lệnh `@ten-skill`.  
+Nó giống như việc sở hữu một thư viện - tất cả sách đều ở đó, nhưng bạn chỉ đọc những cuốn bạn cần thôi.  
+**Mẹo:** Sử dụng [Bản mẫu Khởi đầu (Starter Packs)](BUNDLES.vi.md) để chỉ cài đặt những gì phù hợp với vai trò của bạn.
+
+### Những công cụ AI nào hoạt động với các kỹ năng này?
+
+- ✅ **Claude Code** (Dòng lệnh CLI của Anthropic)
+- ✅ **Gemini CLI** (Google)
+- ✅ **Codex CLI** (OpenAI)
+- ✅ **Cursor** (IDE tích hợp AI)
+- ✅ **Antigravity IDE**
+- ✅ **OpenCode**
+- ⚠️ **GitHub Copilot** (Hỗ trợ một phần qua việc copy-paste)
+
+### Những kỹ năng này có được sử dụng miễn phí không?
+
+**Có!** Repository này được cấp phép theo giấy phép MIT License.
+
+- ✅ Miễn phí cho sử dụng cá nhân.
+- ✅ Miễn phí cho sử dụng thương mại.
+- ✅ Bạn có thể sửa đổi chúng.
+
+### Các kỹ năng có hoạt động ngoại tuyến (offline) không?
+
+Bản thân các file skill được lưu trữ cục bộ trên máy tính của bạn, nhưng trợ lý AI của bạn vẫn cần kết nối internet để hoạt động.
+
+---
+
+## 🔒 Bảo mật & Tin cậy (Cập nhật V3)
+
+### Các Nhãn rủi ro (Risk Labels) có ý nghĩa gì?
+
+Chúng tôi phân loại các kỹ năng để bạn biết mình đang chạy cái gì:
+
+- ⚪ **Safe (Trắng/Xanh)**: Các kỹ năng chỉ đọc, lập kế hoạch hoặc vô hại.
+- 🔴 **Risk (Đỏ)**: Các kỹ năng sửa đổi file (xóa), sử dụng công cụ quét mạng, hoặc thực hiện các hành động có tính phá hủy. **Hãy sử dụng thận trọng.**
+- 🟣 **Official (Tím)**: Được duy trì bởi các nhà cung cấp tin cậy (Anthropic, DeepMind, v.v.).
+
+### Những kỹ năng này có thể hack máy tính của tôi không?
+
+**Không.** Kỹ năng là các file văn bản. Tuy nhiên, chúng *hướng dẫn* AI chạy các dòng lệnh. Nếu một skill nói "xóa toàn bộ file", một AI tuân thủ có thể sẽ thử làm việc đó.  
+_Luôn kiểm tra nhãn rủi ro và xem xét mã nguồn trước khi dùng._
+
+---
+
+## 📦 Cài đặt & Thiết lập
+
+### Tôi nên cài đặt các kỹ năng này ở đâu?
+
+Đường dẫn phổ biến nhất hoạt động với mạng lưới các công cụ AI là `.agent/skills/`:
+
+```bash
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+**Các đường dẫn cụ thể cho từng công cụ:**
+
+- Claude Code: `.claude/skills/`
+- Gemini CLI: `.gemini/skills/`
+- Cursor: `.cursor/skills/` hoặc gốc của dự án.
+
+### Repo này có hoạt động trên Windows không?
+
+**Có**, nhưng một số kỹ năng "Official" (chính thức) sử dụng **symlinks** (liên kết tượng trưng) mà Windows xử lý không tốt theo mặc định.  
+Hãy chạy git clone với lệnh sau:
+
+```bash
+git clone -c core.symlinks=true https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+Hoặc bật "Chế độ Nhà phát triển" (Developer Mode) trong phần Cài đặt của Windows.
+
+### Làm thế nào để cập nhật các kỹ năng?
+
+Chuyển hướng đến thư mục chứa kỹ năng của bạn và kéo (pull) những thay đổi mới nhất:
+
+```bash
+cd .agent/skills
+git pull origin main
+```
+
+---
+
+## 🛠️ Cách sử dụng Skills
+
+### Làm thế nào để gọi một kỹ năng?
+
+Sử dụng biểu tượng `@` theo sau là tên skill:
+
+```bash
+@brainstorming giúp tôi thiết kế một ứng dụng todo
+```
+
+### Tôi có thể dùng nhiều kỹ năng cùng một lúc không?
+
+**Có!** Bạn có thể gọi nhiều kỹ năng:
+
+```bash
+@brainstorming giúp tôi thiết kế phần này, sau đó dùng @writing-plans để tạo danh sách nhiệm vụ.
+```
+
+### Làm thế nào để tôi biết nên dùng kỹ năng nào?
+
+1. **Duyệt qua danh mục**: Xem [Danh mục Skill (Skill Catalog)](../CATALOG.vi.md).
+2. **Tìm kiếm**: `ls skills/ | grep "từ-khóa"`
+3. **Hỏi AI của bạn**: "Bạn có kỹ năng nào để kiểm thử (testing) không?"
+
+---
+
+## 🏗️ Xử lý sự cố
+
+### Trợ lý AI của tôi không nhận diện được kỹ năng
+
+**Các nguyên nhân có thể xảy ra:**
+
+1. **Sai đường dẫn cài đặt**: Kiểm tra tài liệu hướng dẫn của công cụ bạn dùng. Hãy thử `.agent/skills/`.
+2. **Cần khởi động lại**: Khởi động lại AI/IDE sau khi cài đặt.
+3. **Lỗi đánh máy**: Bạn có gõ lầm `@brain-storming` thay vì `@brainstorming` không?
+
+### Một kỹ năng đưa ra lời khuyên sai hoặc lỗi thời
+
+Hãy [Mở một issue](https://github.com/sickn33/antigravity-awesome-skills/issues)!  
+Vui lòng gửi kèm:
+
+- Skill nào?
+- Điều gì đã xảy ra?
+- Đáng lẽ điều gì nên xảy ra?
+
+---
+
+## 🤝 Đóng góp
+
+### Tôi là người mới đối với mã nguồn mở. Tôi có thể đóng góp không?
+
+**Chắc chắn là có!** Chúng tôi chào đón những người mới bắt đầu.
+
+- Sửa lỗi đánh máy.
+- Thêm ví dụ.
+- Cải thiện tài liệu hướng dẫn.  
+Hãy xem [CONTRIBUTING.md](../CONTRIBUTING.vi.md) để biết hướng dẫn chi tiết.
+
+### Pull Request (PR) của tôi thất bại khi kiểm tra "Quality Bar". Tại sao?
+
+Phiên bản V3 áp dụng kiểm soát chất lượng tự động. Skill của bạn có thể đang thiếu:
+
+1. Một `description` (mô tả) hợp lệ.
+2. Các ví dụ sử dụng.  
+Hãy chạy `python3 scripts/validate_skills.py` cục bộ để kiểm tra trước khi đẩy code lên.
+
+### Tôi có thể cập nhật các kỹ năng "Official" không?
+
+**Không.** Các kỹ năng chính thức (trong thư mục `skills/official/`) được đồng bộ từ các nhà cung cấp. Thay vào đó, hãy mở một issue để báo lỗi.
+
+---
+
+## 💡 Mẹo Chuyên nghiệp
+
+- Bắt đầu với `@brainstorming` trước khi xây dựng bất kỳ thứ gì mới.
+- Sử dụng `@systematic-debugging` khi gặp lỗi khó nhằn.
+- Thử `@test-driven-development` để code có chất lượng tốt hơn.
+- Khám phá `@skill-creator` để tự tạo kỹ năng của riêng bạn.
+
+**Vẫn còn thắc mắc?** [Mở một cuộc thảo luận (Discussion)](https://github.com/sickn33/antigravity-awesome-skills/discussions) và chúng tôi sẽ giúp bạn! 🙌

docs/vietnamese/GETTING_STARTED.vi.md

@@ -0,0 +1,108 @@
+# Hướng dẫn Bắt đầu với Antigravity Awesome Skills (V3)
+
+**Bạn mới đến đây? Hướng dẫn này sẽ giúp bạn tăng cường sức mạnh cho trợ lý trợ lý AI của mình chỉ trong 5 phút.**
+
+---
+
+## 🤔 "Skills" (Kỹ năng) là gì?
+
+Các trợ lý AI (như **Claude Code**, **Gemini**, **Cursor**) rất thông minh, nhưng chúng thiếu kiến thức cụ thể về các công cụ và quy trình làm việc của bạn.  
+**Skills** là các hướng dẫn sử dụng chuyên biệt (dưới dạng file markdown) dạy cho AI của bạn cách thực hiện các tác vụ cụ thể một cách hoàn hảo trong mọi lần thực hiện.
+
+**Một phép so sánh:** AI của bạn là một thực tập sinh xuất sắc. **Skills** là các SOP (Quy trình vận hành tiêu chuẩn) biến họ thành một Kỹ sư cao cấp.
+
+---
+
+## ⚡️ Khởi động nhanh: Các "Gói khởi đầu" (Starter Packs)
+
+Đừng lo lắng về con số hơn 552 kỹ năng. Bạn không cần dùng tất cả chúng cùng một lúc.  
+Chúng tôi đã tuyển chọn các **Gói khởi đầu** để bạn có thể bắt đầu sử dụng ngay lập tức.
+
+### 1. Cài đặt Repository
+
+Sao chép các kỹ năng vào thư mục agent của bạn:
+
+```bash
+# Cài đặt phổ thông (hoạt động với hầu hết các agent)
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+```
+
+### 2. Chọn vai trò của bạn
+
+Tìm gói kỹ năng phù hợp với vị trí của bạn (xem [BUNDLES.md](BUNDLES.vi.md)):
+
+| Vai trò               | Tên Gói kỹ năng | Bên trong có những gì?                            |
+| :-------------------- | :-------------- | :------------------------------------------------ |
+| **Web Developer**     | `Web Wizard`    | React Patterns, Tailwind mastery, Frontend Design |
+| **Security Engineer** | `Hacker Pack`   | OWASP, Metasploit, Pentest Methodology            |
+| **Manager / PM**      | `Product Pack`  | Brainstorming, Planning, SEO, Strategy            |
+| **Cơ bản cho tất cả** | `Essentials`    | Clean Code, Planning, Validation (Những thứ cơ bản nhất) |
+
+---
+
+## 🚀 Cách sử dụng một Skill
+
+Sau khi cài đặt, bạn chỉ cần trò chuyện với AI một cách tự nhiên.
+
+### Ví dụ 1: Lập kế hoạch cho một Tính năng (**Essentials**)
+
+> "Sử dụng **@brainstorming** để giúp tôi thiết kế một luồng đăng nhập mới."
+
+**Điều gì sẽ xảy ra:** AI sẽ tải kỹ năng brainstorming, đặt cho bạn các câu hỏi có cấu trúc và tạo ra một bản đặc tả chuyên nghiệp.
+
+### Ví dụ 2: Kiểm tra Code của bạn (**Web Wizard**)
+
+> "Chạy **@lint-and-validate** trên file này và sửa các lỗi."
+
+**Điều gì sẽ xảy ra:** AI sẽ tuân theo các quy tắc linting nghiêm ngặt được định nghĩa trong skill để làm sạch code của bạn.
+
+### Ví dụ 3: Kiểm tra Bảo mật (**Hacker Pack**)
+
+> "Sử dụng **@api-security-best-practices** để xem xét các endpoint API của tôi."
+
+**Điều gì sẽ xảy ra:** AI sẽ kiểm tra code của bạn dựa trên các tiêu chuẩn OWASP.
+
+---
+
+## 🔌 Các công cụ được hỗ trợ
+
+| Công cụ          | Trạng thái      | Đường dẫn         |
+| :--------------- | :-------------- | :---------------- |
+| **Claude Code**  | ✅ Hỗ trợ đầy đủ | `.claude/skills/` |
+| **Gemini CLI**   | ✅ Hỗ trợ đầy đủ | `.gemini/skills/` |
+| **Antigravity**  | ✅ Hỗ trợ gốc   | `.agent/skills/`  |
+| **Cursor**       | ✅ Hỗ trợ gốc   | `.cursor/skills/` |
+| **Copilot**      | ⚠️ Chỉ văn bản  | Copy-paste thủ công |
+
+---
+
+## 🛡️ Sự tin cậy & An toàn (Mới trong bản V3)
+
+Chúng tôi phân loại các kỹ năng để bạn biết mình đang chạy những gì:
+
+- 🟣 **Official (Chính thức)**: Được duy trì bởi Anthropic/Google/Nhà cung cấp (Độ tin cậy cao).
+- 🔵 **Safe (An toàn)**: Các kỹ năng cộng đồng không gây hại (Chỉ đọc/Lập kế hoạch).
+- 🔴 **Risk (Rủi ro)**: Các kỹ năng sửa đổi hệ thống hoặc thực hiện kiểm thử bảo mật (Sử dụng khi được cấp phép).
+
+_Kiểm tra [Danh mục Skill (Skill Catalog)](../CATALOG.vi.md) để xem danh sách đầy đủ._
+
+---
+
+## ❓ FAQ
+
+**H: Tôi có cần cài đặt tất cả 552 kỹ năng không?**  
+Đ: Bạn tải toàn bộ repo về, nhưng AI của bạn chỉ _đọc_ những kỹ năng bạn yêu cầu (hoặc những kỹ năng có liên quan). Nó rất nhẹ!
+
+**H: Tôi có thể tự tạo kỹ năng cho riêng mình không?**  
+Đ: Có! Sử dụng kỹ năng **@skill-creator** để tự xây dựng.
+
+**H: Nó có miễn phí không?**  
+Đ: Có, Giấy phép MIT. Mã nguồn mở mãi mãi.
+
+---
+
+## ⏭️ Các bước tiếp theo
+
+1. [Duyệt qua các Gói kỹ năng (Bundles)](BUNDLES.vi.md)
+2. [Xem các Ví dụ thực tế (Examples)](EXAMPLES.vi.md)
+3. [Đóng góp một Skill mới](../CONTRIBUTING.vi.md)

docs/vietnamese/QUALITY_BAR.vi.md

@@ -0,0 +1,64 @@
+# 🏆 Tiêu chuẩn Chất lượng & Xác thực
+
+Để biến **Antigravity Awesome Skills** từ một tập hợp các script thành một nền tảng đáng tin cậy, mỗi skill (kỹ năng) phải đáp ứng một tiêu chuẩn cụ thể về chất lượng và an toàn.
+
+## Huy hiệu "Đã xác thực" (Validated) ✅
+
+Một skill chỉ nhận được huy hiệu "Đã xác thực" nếu nó vượt qua **5 bước kiểm tra tự động** sau:
+
+### 1. Tính toàn vẹn của siêu dữ liệu (Metadata Integrity)
+
+Phần frontmatter trong `SKILL.md` phải là mã YAML hợp lệ và chứa:
+
+- `name`: Định dạng Kebab-case, khớp với tên thư mục.
+- `description`: Dưới 200 ký tự, nêu rõ giá trị mang lại.
+- `risk`: Thuộc một trong các loại `[none, safe, critical, offensive]`.
+- `source`: URL dẫn đến nguồn gốc (hoặc "self" nếu là nội dung gốc).
+
+### 2. Điều kiện kích hoạt rõ ràng ("Khi nào nên dùng")
+
+Skill BẮT BUỘC phải có một phần nêu rõ thời điểm nên kích hoạt nó.
+
+- **Tốt**: "Sử dụng khi người dùng yêu cầu debug (gỡ lỗi) một component React."
+- **Tệ**: "Skill này giúp bạn xử lý code."
+
+### 3. Phân loại An toàn & Rủi ro
+
+Mỗi skill phải khai báo mức độ rủi ro của nó:
+
+- 🟢 **none**: Chỉ là văn bản/tư duy thuần túy (ví dụ: Brainstorming).
+- 🔵 **safe**: Đọc file, chạy các lệnh an toàn (ví dụ: Linter).
+- 🟠 **critical**: Sửa đổi trạng thái, xóa file, push lên môi trường production (ví dụ: Git Push).
+- 🔴 **offensive**: Các công cụ Pentesting/Red Team. **BẮT BUỘC** phải có cảnh báo "Chỉ dành cho mục đích sử dụng đã được cấp phép".
+
+### 4. Ví dụ thực tế (Copy-Pasteable)
+
+Ít nhất một khối code hoặc ví dụ tương tác mà người dùng (hoặc agent) có thể sử dụng ngay lập tức.
+
+### 5. Giới hạn rõ ràng (Explicit Limitations)
+
+Danh sách các trường hợp biên hoặc những việc mà skill _không thể_ thực hiện.
+
+- _Ví dụ_: "Không hoạt động trên Windows nếu không có WSL."
+
+---
+
+## Các cấp độ Hỗ trợ
+
+Chúng tôi cũng phân loại skill dựa trên người duy trì chúng:
+
+| Cấp độ        | Huy hiệu | Ý nghĩa                                              |
+| :------------ | :------- | :--------------------------------------------------- |
+| **Official**  | 🟣       | Do đội ngũ cốt lõi duy trì. Độ tin cậy cao.          |
+| **Community** | ⚪       | Do cộng đồng đóng góp. Hỗ trợ theo khả năng tốt nhất. |
+| **Verified**  | ✨       | Skill cộng đồng đã vượt qua vòng kiểm duyệt thủ công chuyên sâu. |
+
+---
+
+## Cách Xác thực Skill của bạn
+
+Chạy script xác thực trước khi gửi Pull Request (PR):
+
+```bash
+python3 scripts/validate_skills.py --strict
+```

docs/vietnamese/README.vi.md

@@ -0,0 +1,190 @@
+# 🌌 Antigravity Awesome Skills: 552+ Kỹ năng (Skills) cho Claude Code, Gemini CLI, Cursor, Copilot và nhiều hơn nữa
+
+> **Bộ sưu tập tối ưu gồm hơn 552 Kỹ năng Phổ quát cho các Trợ lý Lập trình AI — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Claude Code](https://img.shields.io/badge/Claude%20Code-Anthropic-purple)](https://claude.ai)
+[![Gemini CLI](https://img.shields.io/badge/Gemini%20CLI-Google-blue)](https://github.com/google-gemini/gemini-cli)
+[![Codex CLI](https://img.shields.io/badge/Codex%20CLI-OpenAI-green)](https://github.com/openai/codex)
+[![Cursor](https://img.shields.io/badge/Cursor-AI%20IDE-orange)](https://cursor.sh)
+[![Copilot](https://img.shields.io/badge/GitHub%20Copilot-VSCode-lightblue)](https://github.com/features/copilot)
+[![OpenCode](https://img.shields.io/badge/OpenCode-CLI-gray)](https://github.com/opencode-ai/opencode)
+[![Antigravity](https://img.shields.io/badge/Antigravity-DeepMind-red)](https://github.com/sickn33/antigravity-awesome-skills)
+
+**Antigravity Awesome Skills** là một thư viện được tuyển chọn và kiểm chứng kỹ lưỡng với **552 kỹ năng hiệu suất cao** được thiết kế để hoạt động mượt mà trên tất cả các trợ lý lập trình AI lớn:
+
+- 🟣 **Claude Code** (Anthropic CLI)
+- 🔵 **Gemini CLI** (Google DeepMind)
+- 🟢 **Codex CLI** (OpenAI)
+- 🔴 **Antigravity IDE** (Google DeepMind)
+- 🩵 **GitHub Copilot** (VSCode Extension)
+- 🟠 **Cursor** (AI-native IDE)
+- ⚪ **OpenCode** (Mã nguồn mở CLI)
+
+**Chào mừng bạn đến với Phiên bản V4.0.0 Enterprise.** Đây không chỉ là một danh sách các tập lệnh (scripts); nó là một hệ điều hành hoàn chỉnh cho Trợ lý AI của bạn.
+
+### 1. 🐣 Bối cảnh: Đây là gì?
+
+**Antigravity Awesome Skills** (Phiên bản 4.0.0) là một bản nâng cấp khổng lồ cho khả năng của AI.
+
+Các trợ lý AI (như Claude Code, Cursor, hoặc Gemini) rất thông minh, nhưng chúng thiếu các **công cụ chuyên biệt**. Chúng không biết "Quy trình Triển khai" của công ty bạn hoặc cú pháp cụ thể cho "AWS CloudFormation".  
+**Skills** là các tệp markdown nhỏ dạy cho chúng cách thực hiện những tác vụ cụ thể này một cách chính xác trong mọi lần thực thi.
+...
+Repository này cung cấp các kỹ năng thiết yếu để biến trợ lý AI của bạn thành một **đội ngũ chuyên gia số toàn năng**, bao gồm các khả năng chính thức từ **Anthropic**, **OpenAI**, **Google**, **Supabase**, và **Vercel Labs**.
+...
+Cho dù bạn đang sử dụng **Gemini CLI**, **Claude Code**, **Codex CLI**, **Cursor**, **GitHub Copilot**, **Antigravity**, hay **OpenCode**, những kỹ năng này được thiết kế để có thể sử dụng ngay lập tức và tăng cường sức mạnh cho trợ lý AI của bạn.
+
+Repository này tập hợp những khả năng tốt nhất từ khắp cộng đồng mã nguồn mở, biến trợ lý AI của bạn thành một đội ngũ chuyên gia số toàn năng có khả năng Kỹ thuật, Thiết kế, Bảo mật, Marketing và Vận hành Tự động.
+
+## Tính năng & Danh mục
+
+Repository được tổ chức thành các lĩnh vực chuyên biệt để biến AI của bạn thành một chuyên gia trên toàn bộ vòng đời phát triển phần mềm:
+
+| Danh mục | Trọng tâm | Ví dụ kỹ năng |
+| :--- | :--- | :--- |
+| Kiến trúc (52) | Thiết kế hệ thống, ADRs, C4 và các mẫu có thể mở rộng | `architecture`, `c4-context`, `senior-architect` |
+| Kinh doanh (35) | Tăng trưởng, định giá, CRO, SEO và thâm nhập thị trường | `copywriting`, `pricing-strategy`, `seo-audit` |
+| Dữ liệu & AI (81) | Ứng dụng LLM, RAG, agents, khả năng quan sát, phân tích | `rag-engineer`, `prompt-engineer`, `langgraph` |
+| Phát triển (72) | Làm chủ ngôn ngữ, mẫu thiết kế framework, chất lượng code | `typescript-expert`, `python-patterns`, `react-patterns` |
+| Tổng quát (95) | Lập kế hoạch, tài liệu, vận hành sản phẩm, viết bài, hướng dẫn | `brainstorming`, `doc-coauthoring`, `writing-plans` |
+| Hạ tầng (72) | DevOps, cloud, serverless, triển khai, CI/CD | `docker-expert`, `aws-serverless`, `vercel-deployment` |
+| Bảo mật (107) | AppSec, pentesting, phân tích lỗ hổng, tuân thủ | `api-security-best-practices`, `sql-injection-testing`, `vulnerability-scanner` |
+| Kiểm thử (21) | TDD, thiết kế kiểm thử, sửa lỗi, quy trình QA | `test-driven-development`, `testing-patterns`, `test-fixing` |
+| Quy trình (17) | Tự động hóa, điều phối, công việc, agents | `workflow-automation`, `inngest`, `trigger-dev` |
+
+## Bộ sưu tập Tuyển chọn
+
+[Xem các Gói khởi đầu tại docs/vietnamese/BUNDLES.md](docs/vietnamese/BUNDLES.vi.md) để tìm bộ công cụ hoàn hảo cho vai trò của bạn.
+
+## Duyệt hơn 552 Kỹ năng
+
+Chúng tôi đã chuyển danh sách đầy đủ các kỹ năng sang một danh mục riêng biệt để giữ cho file README này gọn gàng.
+
+👉 **[Xem Danh mục Kỹ năng Đầy đủ (CATALOG.vi.md)](CATALOG.vi.md)**
+
+## Cài đặt
+
+Để sử dụng các kỹ năng này với **Claude Code**, **Gemini CLI**, **Codex CLI**, **Cursor**, **Antigravity**, hoặc **OpenCode**, hãy clone repository này vào thư mục kỹ năng của assistant của bạn:
+
+```bash
+# Cài đặt phổ thông (hoạt động với hầu hết các công cụ)
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .agent/skills
+
+# Dành riêng cho Claude Code
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .claude/skills
+
+# Dành riêng cho Gemini CLI
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .gemini/skills
+
+# Dành riêng cho Cursor
+git clone https://github.com/sickn33/antigravity-awesome-skills.git .cursor/skills
+```
+
+---
+
+## Cách thức Đóng góp
+
+Chúng tôi chào đón mọi sự đóng góp từ cộng đồng! Để thêm một kỹ năng mới:
+
+1. **Fork** repository.
+2. **Tạo một thư mục mới** bên trong `skills/` cho kỹ năng của bạn.
+3. **Thêm file `SKILL.md`** với phần frontmatter bắt buộc (tên và mô tả).
+4. **Chạy kiểm tra xác thực**: `python3 scripts/validate_skills.py`.
+5. **Gửi một Pull Request**.
+
+Vui lòng đảm bảo kỹ năng của bạn tuân thủ các thực hành tốt nhất của Antigravity/Claude Code.
+
+---
+
+## Người đóng góp & Ghi công
+
+Chúng tôi đứng trên vai của những người khổng lồ.
+
+👉 **[Xem Sổ cái Ghi công Đầy đủ (docs/vietnamese/SOURCES.vi.md)](docs/vietnamese/SOURCES.vi.md)**
+
+Các nguồn đóng góp và nguồn chính bao gồm:
+
+- **HackTricks**
+- **OWASP**
+- **Anthropic / OpenAI / Google**
+- **Cộng đồng mã nguồn mở**
+
+Bộ sưu tập này sẽ không thể hình thành nếu không có công việc tuyệt vời của cộng đồng Claude Code và các nguồn chính thức:
+
+### Các nguồn Chính thức
+
+- **[anthropics/skills](https://github.com/anthropics/skills)**: Thư mục skill chính thức của Anthropic - Xử lý tài liệu (DOCX, PDF, PPTX, XLSX), Hướng dẫn thương hiệu, Giao tiếp nội bộ.
+- **[anthropics/claude-cookbooks](https://github.com/anthropics/claude-cookbooks)**: Các notebook và công thức chính thức để xây dựng với Claude.
+- **[remotion-dev/skills](https://github.com/remotion-dev/skills)**: Skills chính thức của Remotion - Tạo video trong React với 28 quy tắc mô-đun.
+- **[vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills)**: Skills chính thức của Vercel Labs - Thực hành tốt nhất cho React, Hướng dẫn thiết kế Web.
+- **[openai/skills](https://github.com/openai/skills)**: Danh mục skill của OpenAI Codex - Các kỹ năng của Agent, Trình tạo Skill, Lập kế hoạch Súc tích.
+- **[supabase/agent-skills](https://github.com/supabase/agent-skills)**: Skills chính thức của Supabase - Thực hành tốt nhất cho Postgres.
+
+### Những người đóng góp từ Cộng đồng
+
+- **[rmyndharis/antigravity-skills](https://github.com/rmyndharis/antigravity-skills)**: Cho sự đóng góp khổng lồ của hơn 300+ kỹ năng Enterprise và logic tạo danh mục.
+- **[obra/superpowers](https://github.com/obra/superpowers)**: Bản "Superpowers" gốc bởi Jesse Vincent.
+- **[guanyang/antigravity-skills](https://github.com/guanyang/antigravity-skills)**: Các bản mở rộng Antigravity cốt lõi.
+- **[diet103/claude-code-infrastructure-showcase](https://github.com/diet103/claude-code-infrastructure-showcase)**: Cơ sở hạ tầng và Hướng dẫn cho Backend/Frontend.
+- **[ChrisWiles/claude-code-showcase](https://github.com/ChrisWiles/claude-code-showcase)**: Các mẫu React UI và Hệ thống Thiết kế.
+- **[travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills)**: Loki Mode và tích hợp Playwright.
+- **[zebbern/claude-code-guide](https://github.com/zebbern/claude-code-guide)**: Bộ công cụ bảo mật toàn diện & Hướng dẫn (Nguồn cho khoảng 60 kỹ năng mới).
+- **[alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills)**: Bộ công cụ Kỹ sư cao cấp và PM.
+- **[karanb192/awesome-claude-skills](https://github.com/karanb192/awesome-claude-skills)**: Một danh sách khổng lồ các kỹ năng đã được xác thực cho Claude Code.
+- **[zircote/.claude](https://github.com/zircote/.claude)**: Tham chiếu kỹ năng phát triển cho Shopify.
+- **[vibeforge1111/vibeship-spawner-skills](https://github.com/vibeforge1111/vibeship-spawner-skills)**: Trợ lý AI, Tích hợp, Công cụ của nhà sáng tạo (57 kỹ năng, Apache 2.0).
+- **[coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills)**: Các kỹ năng Marketing cho CRO, copywriting, SEO, quảng cáo trả phí và tăng trưởng (23 kỹ năng, MIT).
+- **[vudovn/antigravity-kit](https://github.com/vudovn/antigravity-kit)**: Các mẫu AI Agent với Kỹ năng, Agents và Quy trình làm việc (33 kỹ năng, MIT).
+- **[affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)**: Bộ sưu tập cấu hình Claude Code đầy đủ từ người chiến thắng cuộc thi hackathon của Anthropic - chỉ phần kỹ năng (8 kỹ năng, MIT).
+- **[webzler/agentMemory](https://github.com/webzler/agentMemory)**: Nguồn cho kỹ năng agent-memory-mcp.
+- **[sstklen/claude-api-cost-optimization](https://github.com/sstklen/claude-api-cost-optimization)**: Tiết kiệm 50-90% chi phí Claude API với các chiến lược tối ưu hóa thông minh (MIT).
+
+### Nguồn cảm hứng
+
+- **[f/awesome-chatgpt-prompts](https://github.com/f/awesome-chatgpt-prompts)**: Cảm hứng cho Thư viện Prompt.
+- **[leonardomso/33-js-concepts](https://github.com/leonardomso/33-js-concepts)**: Cảm hứng cho việc Làm chủ JavaScript.
+
+---
+
+## Giấy phép
+
+Giấy phép MIT. Xem file [LICENSE](LICENSE) để biết chi tiết.
+
+## Cộng đồng
+
+- [Cộng đồng (Community Guidelines)](docs/vietnamese/COMMUNITY_GUIDELINES.vi.md)
+- [Chính sách Bảo mật (Security Policy)](docs/vietnamese/SECURITY_GUARDRAILS.vi.md)
+
+---
+
+## Những người đóng góp cho Repo
+
+Chúng tôi chính thức cảm ơn những người đóng góp sau đây đã giúp làm cho repository này trở nên tuyệt vời!
+
+- [mvanhorn](https://github.com/mvanhorn)
+- [rookie-ricardo](https://github.com/rookie-ricardo)
+- [sck_0](https://github.com/sck_0)
+- [Munir Abbasi](https://github.com/munirabbasi)
+- [Mohammad Faiz](https://github.com/mohdfaiz2k9)
+- [Ianj332](https://github.com/Ianj332)
+- [sickn33](https://github.com/sickn33)
+- [GuppyTheCat](https://github.com/GuppyTheCat)
+- [Tiger-Foxx](https://github.com/Tiger-Foxx)
+- [arathiesh](https://github.com/arathiesh)
+- [1bcMax](https://github.com/1bcMax)
+- [Ahmed Rehan](https://github.com/ar27111994)
+- [BenedictKing](https://github.com/BenedictKing)
+- [Nguyen Huu Loc](https://github.com/LocNguyenSGU)
+- [Owen Wu](https://github.com/yubing744)
+- [SuperJMN](https://github.com/SuperJMN)
+- [Viktor Ferenczi](https://github.com/viktor-ferenczi)
+- [krisnasantosa15](https://github.com/krisnasantosa15)
+- [raeef1001](https://github.com/raeef1001)
+- [taksrules](https://github.com/taksrules)
+- [zebbern](https://github.com/zebbern)
+- [Đỗ Khắc Gia Khoa](https://github.com/dokhacgiakhoa)
+- [vuth-dogo](https://github.com/vuth-dogo)
+
+## Lịch sử Star
+
+[![Star History Chart](https://api.star-history.com/svg?repos=sickn33/antigravity-awesome-skills&type=date&legend=top-left)](https://www.star-history.com/#sickn33/antigravity-awesome-skills&type=date&legend=top-left)

docs/vietnamese/SECURITY.vi.md

@@ -0,0 +1,19 @@
+# Chính sách Bảo mật (Security Policy)
+
+## Các Phiên bản được Hỗ trợ
+
+Chúng tôi theo dõi nhánh `main`.
+
+## Báo cáo Lỗ hổng
+
+**KHÔNG** mở Issue công khai cho các lỗ hổng bảo mật.
+
+Nếu bạn tìm thấy một lỗ hổng bảo mật (ví dụ: một kỹ năng vượt qua kiểm tra "Sử dụng có Phép" hoặc thực thi mã độc hại mà không cảnh báo):
+
+1. Email: `security@antigravity.dev` (Placeholder)
+2. Hoặc mở một **Private Advisory** (Cảnh báo Bảo mật Riêng tư) trên repository này.
+
+## Chính sách Kỹ năng Tấn công (Offensive Skills Policy)
+
+Vui lòng đọc [Rào chắn Bảo mật (Security Guardrails)](docs/vietnamese/SECURITY_GUARDRAILS.vi.md) của chúng tôi.
+Tất cả các kỹ năng tấn công (offensive skills) chỉ dành nghiêm ngặt cho **mục đích giáo dục và hoạt động chuyên nghiệp đã được cấp phép**.

docs/vietnamese/SECURITY_GUARDRAILS.vi.md

@@ -0,0 +1,51 @@
+# 🛡️ Chính sách Bảo mật & Rào chắn An toàn (Guardrails)
+
+Antigravity Awesome Skills là một bộ công cụ mạnh mẽ. Và quyền lực lớn luôn đi kèm với trách nhiệm lớn. Tài liệu này xác định **Quy tắc Ứng xử** cho tất cả các khả năng bảo mật và tấn công trong repository này.
+
+## 🔴 Chính sách đối với Skill Tấn công (Vạch kẻ đỏ)
+
+**Skill Tấn công là gì?**
+Bất kỳ kỹ năng (skill) nào được thiết kế để xâm nhập, khai thác, làm gián đoạn hoặc mô phỏng tấn công chống lại các hệ thống.  
+_Ví dụ: Pentesting (Kiểm thử xâm nhập), SQL Injection, Mô phỏng Phishing, Red Teaming._
+
+### 1. Tuyên bố từ chối trách nhiệm "Chỉ dành cho mục đích sử dụng đã được phê duyệt"
+
+Mỗi skill tấn công **BẮT BUỘC** phải bắt đầu bằng tuyên bố từ chối trách nhiệm chính xác như sau trong file `SKILL.md`:
+
+> **⚠️ CHỈ DÀNH CHO MỤC ĐÍCH SỬ DỤNG ĐÃ ĐƯỢC PHÊ DUYỆT**  
+> Skill này chỉ dành cho mục đích giáo dục hoặc đánh giá bảo mật đã được cấp phép.  
+> Bạn phải có sự cho phép rõ ràng bằng văn bản từ chủ sở hữu hệ thống trước khi sử dụng công cụ này.  
+> Việc lạm dụng công cụ này là bất hợp pháp và bị nghiêm cấm hoàn toàn.
+
+### 2. Yêu cầu Xác nhận từ Người dùng
+
+Các skill tấn công **KHÔNG BAO GIỜ** được chạy hoàn toàn tự động một cách tự ý (autonomously).
+
+- **Yêu cầu**: Mô tả hoặc hướng dẫn của skill phải yêu cầu agent (trợ lý AI) *hỏi xác nhận của người dùng* trước khi thực thi bất kỳ lệnh khai thác hoặc tấn công nào.
+- **Hướng dẫn cho Agent**: "Yêu cầu người dùng xác minh URL/IP mục tiêu trước khi chạy."
+
+### 3. Thiết kế để An toàn
+
+- **Không chứa mã độc (Weaponized Payloads)**: Các skill không được bao gồm malware hoạt động, ransomware, hoặc các mã khai thác không mang tính giáo dục.
+- **Khuyến nghị dùng Sandbox**: Các hướng dẫn nên khuyến nghị chạy trong môi trường cô lập (Docker/VM).
+
+---
+
+## 🔵 Chính sách đối với Skill Phòng thủ
+
+**Skill Phòng thủ là gì?**
+Các công cụ dùng để tăng cường bảo mật (hardening), kiểm tra (auditing), giám sát (monitoring), hoặc bảo vệ hệ thống.  
+_Ví dụ: Linting (Kiểm tra lỗi code), Phân tích Log, Kiểm tra Cấu hình._
+
+- **Quyền riêng tư dữ liệu**: Các kỹ năng phòng thủ không được tải dữ liệu lên các máy chủ bên thứ ba mà không có sự đồng ý rõ ràng của người dùng.
+- **Không gây hư tổn (Non-Destructive)**: Các quy trình kiểm tra (audits) nên mặc định ở chế độ chỉ đọc (read-only).
+
+---
+
+## ⚖️ Tuyên bố Pháp lý
+
+Bằng việc sử dụng repository này, bạn đồng ý rằng:
+
+1. Bạn tự chịu trách nhiệm về hành động của mình.
+2. Các tác giả và người đóng góp không chịu trách nhiệm cho bất kỳ thiệt hại nào do các công cụ này gây ra.
+3. Bạn sẽ tuân thủ tất cả các luật địa phương, tiểu bang và liên bang liên quan đến an ninh mạng.

docs/vietnamese/SKILLS_README.vi.md

@@ -0,0 +1,106 @@
+# Thư mục Kỹ năng (Skills Directory)
+
+**Chào mừng đến với thư mục Kỹ năng!** Đây là nơi tập hợp tất cả 179+ kỹ năng AI chuyên biệt.
+
+## 🤔 Kỹ năng là gì?
+
+Kỹ năng là các bộ hướng dẫn chuyên biệt dạy trợ lý AI cách xử lý các tác vụ cụ thể. Hãy nghĩ về chúng như các module kiến thức chuyên gia mà AI của bạn có thể tải theo yêu cầu.
+
+**Hình dung đơn giản:** Giống như bạn có thể tham khảo ý kiến các chuyên gia khác nhau (một nhà thiết kế, một chuyên gia bảo mật, một chuyên gia Marketing), các kỹ năng cho phép AI trở thành chuyên gia trong các lĩnh vực khác nhau ngay khi bạn cần.
+
+---
+
+## 📂 Cấu trúc Thư mục
+
+Mỗi kỹ năng nằm trong thư mục riêng với cấu trúc sau:
+
+```
+skills/
+├── skill-name/              # Thư mục kỹ năng riêng lẻ
+│   ├── SKILL.md             # Định nghĩa kỹ năng chính (bắt buộc)
+│   ├── scripts/             # Scripts hỗ trợ (tùy chọn)
+│   ├── examples/            # Ví dụ sử dụng (tùy chọn)
+│   └── resources/           # Templates & tài nguyên (tùy chọn)
+```
+
+**Lưu ý quan trọng:** Chỉ file `SKILL.md` là bắt buộc. Mọi thứ khác là tùy chọn!
+
+---
+
+## Cách sử dụng Kỹ năng
+
+### Bước 1: Đảm bảo kỹ năng đã được thiết lập
+Các file kỹ năng nên nằm trong thư mục `.agent/skills/` của bạn (hoặc `.claude/skills/`, `.gemini/skills/`, v.v.)
+
+### Bước 2: Kích hoạt kỹ năng trong cuộc trò chuyện với AI
+Sử dụng biểu tượng `@` theo sau bởi tên kỹ năng:
+
+```
+@brainstorming giúp tôi thiết kế một ứng dụng todo
+```
+
+hoặc
+
+```
+@stripe-integration thêm xử lý thanh toán vào ứng dụng của tôi
+```
+
+### Bước 3: AI trở thành chuyên gia
+AI tải kiến thức của kỹ năng đó và giúp bạn với chuyên môn đặc thù!
+
+---
+
+## Tìm kiếm Kỹ năng
+
+### Cách 1: Duyệt thư mục này
+```bash
+ls skills/
+```
+
+### Cách 2: Tìm kiếm theo từ khóa
+```bash
+ls skills/ | grep "từ khóa"
+```
+
+### Cách 3: Kiểm tra README chính
+Xem [README chính](../README.vi.md) để biết danh sách đầy đủ tất cả 179+ kỹ năng được tổ chức theo danh mục.
+
+---
+
+## 💡 Các Kỹ năng Phổ biến để Thử nghiệm
+
+**Cho người mới bắt đầu:**
+- `@brainstorming` - Thiết kế trước khi code
+- `@systematic-debugging` - Sửa lỗi một cách có phương pháp
+- `@git-pushing` - Commit với thông báo tốt
+
+**Cho lập trình viên:**
+- `@test-driven-development` - Viết test trước
+- `@react-best-practices` - Các mẫu React hiện đại
+- `@senior-fullstack` - Phát triển Full-stack
+
+**Cho bảo mật:**
+- `@ethical-hacking-methodology` - Cơ bản về bảo mật
+- `@burp-suite-testing` - Kiểm thử bảo mật ứng dụng web
+
+---
+
+## Tạo Kỹ năng Riêng của Bạn
+
+Muốn tạo một kỹ năng mới? Hãy xem:
+1. [CONTRIBUTING.vi.md](../docs/vietnamese/CONTRIBUTING.vi.md) - Cách đóng góp
+2. [docs/vietnamese/SKILL_ANATOMY.vi.md](../docs/vietnamese/SKILL_ANATOMY.vi.md) - Hướng dẫn cấu trúc kỹ năng
+3. `@skill-creator` - Sử dụng kỹ năng này để tạo kỹ năng mới!
+
+---
+
+## Tài liệu Tham khảo
+
+- **[Bắt đầu](../docs/vietnamese/GETTING_STARTED.vi.md)** - Hướng dẫn bắt đầu nhanh
+- **[Ví dụ](../docs/vietnamese/EXAMPLES.vi.md)** - Ví dụ sử dụng thực tế
+- **[FAQ](../docs/vietnamese/FAQ.vi.md)** - Các câu hỏi thường gặp
+- **[Hướng dẫn Trực quan](../docs/vietnamese/VISUAL_GUIDE.vi.md)** - Biểu đồ và lưu đồ
+
+---
+
+**Cần trợ giúp?** Kiểm tra [FAQ](../docs/vietnamese/FAQ.vi.md) hoặc mở một issue trên GitHub!

docs/vietnamese/SKILL_ANATOMY.vi.md

@@ -0,0 +1,605 @@
+# Cấu trúc của một Skill - Hiểu về Hệ thống
+
+**Bạn muốn hiểu cách các skill (kỹ năng) hoạt động bên trong?** Hướng dẫn này sẽ phân tích chi tiết từng phần của một file skill.
+
+---
+
+## 📁 Cấu trúc Thư mục Cơ bản
+
+```
+skills/
+└── my-skill-name/
+    ├── SKILL.md              ← Bắt buộc: Định nghĩa skill chính
+    ├── examples/             ← Tùy chọn: Các file ví dụ
+    │   ├── example1.js
+    │   └── example2.py
+    ├── scripts/              ← Tùy chọn: Các script hỗ trợ
+    │   └── helper.sh
+    ├── templates/            ← Tùy chọn: Các bản mẫu code (templates)
+    │   └── template.tsx
+    ├── references/           ← Tùy chọn: Tài liệu tham khảo
+    │   └── api-docs.md
+    └── README.md             ← Tùy chọn: Tài liệu bổ sung
+```
+
+**Quy tắc Cốt lõi:** Chỉ có file `SKILL.md` là bắt buộc. Tất cả những thành phần khác đều là tùy chọn!
+
+---
+
+## Cấu trúc file SKILL.md
+
+Mỗi file `SKILL.md` có hai phần chính:
+
+### 1. Frontmatter (Siêu dữ liệu - Metadata)
+
+### 2. Nội dung (Hướng dẫn - Instructions)
+
+Hãy cùng phân tích chi tiết từng phần:
+
+---
+
+## Phần 1: Frontmatter
+
+Frontmatter nằm ở ngay đầu file, được bao bọc bởi cặp `---`:
+
+```markdown
+---
+name: my-skill-name
+description: "Mô tả ngắn gọn về chức năng của skill này"
+---
+```
+
+### Các trường Bắt buộc
+
+#### `name`
+
+- **Định nghĩa:** Mã định danh của skill.
+- **Định dạng:** chữ-thường-có-dấu-gạch-ngang (kebab-case).
+- **Yêu cầu:** Phải khớp hoàn toàn với tên thư mục.
+- **Ví dụ:** `stripe-integration`
+
+#### `description`
+
+- **Định nghĩa:** Tóm tắt chức năng trong một câu.
+- **Định dạng:** Chuỗi ký tự nằm trong dấu ngoặc kép.
+- **Độ dài:** Nên dưới 150 ký tự.
+- **Ví dụ:** `"Các mẫu tích hợp thanh toán Stripe bao gồm checkout, đăng ký gói (subscriptions) và webhooks"`
+
+### Các trường Tùy chọn
+
+Một số skill bao gồm thêm siêu dữ liệu bổ sung:
+
+```markdown
+---
+name: my-skill-name
+description: "Mô tả ngắn"
+risk: "safe" # safe | risk | official
+source: "community"
+tags: ["react", "typescript"]
+---
+```
+
+---
+
+## Phần 2: Nội dung
+
+Sau phần frontmatter là nội dung thực tế của skill. Dưới đây là cấu trúc được đề xuất:
+
+### Các mục Đề xuất
+
+#### 1. Tiêu đề (H1)
+
+```markdown
+# Tiêu đề Skill
+```
+
+- Sử dụng tiêu đề rõ ràng, mang tính mô tả.
+- Thường khớp hoặc mở rộng từ tên skill.
+
+#### 2. Tổng quan (Overview)
+
+```markdown
+## Tổng quan
+ 
+Một giải thích ngắn gọn về chức năng của skill và lý do tại sao nó tồn tại.
+Khoảng 2-4 câu là lý tưởng.
+```
+
+#### 3. Khi nào cần sử dụng (When to Use)
+
+```markdown
+## Khi nào nên sử dụng Skill này
+ 
+- Sử dụng khi bạn cần [tình huống 1]
+- Sử dụng khi làm việc với [tình huống 2]
+- Sử dụng khi người dùng hỏi về [tình huống 3]
+```
+
+**Tại sao điều này quan trọng:** Giúp AI biết khi nào cần kích hoạt skill này.
+
+#### 4. Hướng dẫn Cốt lõi (Core Instructions)
+
+```markdown
+## Cách hoạt động
+ 
+### Bước 1: [Hành động]
+ 
+Hướng dẫn chi tiết...
+ 
+### Bước 2: [Hành động]
+ 
+Hướng dẫn thêm...
+```
+
+**Đây là linh hồn của skill** - các bước rõ ràng và có thể thực hiện được.
+
+#### 5. Ví dụ (Examples)
+
+```markdown
+## Ví dụ
+ 
+### Ví dụ 1: [Trường hợp sử dụng]
+ 
+\`\`\`javascript
+// Code ví dụ
+\`\`\`
+ 
+### Ví dụ 2: [Trường hợp sử dụng khác]
+ 
+\`\`\`javascript
+// Thêm code
+\`\`\`
+```
+
+**Tại sao ví dụ lại quan trọng:** Chúng cho AI thấy chính xác kết quả đầu ra tốt trông như thế nào.
+
+#### 6. Thực hành Tốt nhất (Best Practices)
+
+```markdown
+## Thực hành Tốt nhất
+ 
+- ✅ Nên làm điều này
+- ✅ Cũng nên làm điều này
+- ❌ Không nên làm điều này
+- ❌ Tránh điều này
+```
+
+#### 7. Các lỗi thường gặp (Common Pitfalls)
+
+```markdown
+## Các lỗi thường gặp
+ 
+- **Vấn đề:** Mô tả lỗi
+  **Giải pháp:** Cách khắc phục
+```
+
+#### 8. Các Skill liên quan (Related Skills)
+
+```markdown
+## Các Skill liên quan
+ 
+- `@other-skill` - Khi nào nên dùng skill này thay thế
+- `@complementary-skill` - Cách các skill này hoạt động cùng nhau
+```
+
+---
+
+## Viết Hướng dẫn Hiệu quả
+
+### Sử dụng Ngôn ngữ Rõ ràng, Trực tiếp
+
+**❌ Không tốt:**
+
+```markdown
+Bạn có lẽ nên cân nhắc việc kiểm tra xem người dùng đã xác thực hay chưa.
+```
+
+**✅ Tốt:**
+
+```markdown
+Kiểm tra xem người dùng đã được xác thực chưa trước khi tiếp tục.
+```
+
+### Sử dụng Động từ Hành động
+
+**❌ Không tốt:**
+
+```markdown
+File nên được tạo ra...
+```
+
+**✅ Tốt:**
+
+```markdown
+Tạo file...
+```
+
+### Cụ thể và Chi tiết
+
+**❌ Không tốt:**
+
+```markdown
+Thiết lập cơ sở dữ liệu một cách chính xác.
+```
+
+**✅ Tốt:**
+
+```markdown
+1. Tạo cơ sở dữ liệu PostgreSQL
+2. Chạy migration: `npm run migrate`
+3. Nạp dữ liệu ban đầu (seed): `npm run seed`
+```
+
+---
+
+## Các Thành phần Tùy chọn
+
+### Thư mục Scripts
+
+Nếu skill của bạn cần các script hỗ trợ:
+
+```
+scripts/
+├── setup.sh          ← Tự động hóa thiết lập
+├── validate.py       ← Công cụ kiểm tra (validation)
+└── generate.js       ← Công cụ tạo code (generators)
+```
+
+**Tham chiếu chúng trong SKILL.md:**
+
+```markdown
+Chạy script thiết lập:
+\`\`\`bash
+bash scripts/setup.sh
+\`\`\`
+```
+
+### Thư mục Examples
+
+Các ví dụ thực tế minh họa skill:
+
+```
+examples/
+├── basic-usage.js
+├── advanced-pattern.ts
+└── full-implementation/
+    ├── index.js
+    └── config.json
+```
+
+### Thư mục Templates
+
+Các mẫu code có thể tái sử dụng:
+
+```
+templates/
+├── component.tsx
+├── test.spec.ts
+└── config.json
+```
+
+**Tham chiếu trong SKILL.md:**
+
+```markdown
+Sử dụng bản mẫu này làm điểm bắt đầu:
+\`\`\`typescript
+{{#include templates/component.tsx}}
+\`\`\`
+```
+
+### Thư mục References
+
+Tài liệu bên ngoài hoặc tham chiếu API:
+
+```
+references/
+├── api-docs.md
+├── best-practices.md
+└── troubleshooting.md
+```
+
+---
+
+## Hướng dẫn về Quy mô Skill
+
+### Skill Tối giản (Minimum Viable Skill)
+
+- **Frontmatter:** name + description
+- **Nội dung:** 100-200 từ
+- **Các mục:** Tổng quan + Hướng dẫn
+
+### Skill Tiêu chuẩn (Standard Skill)
+
+- **Frontmatter:** name + description
+- **Nội dung:** 300-800 từ
+- **Các mục:** Tổng quan + Khi nào sử dụng + Hướng dẫn + Ví dụ
+
+### Skill Toàn diện (Comprehensive Skill)
+
+- **Frontmatter:** name + description + các trường tùy chọn
+- **Nội dung:** 800-2000 từ
+- **Các mục:** Đầy đủ tất cả các mục đề xuất
+- **Bổ sung:** Scripts, ví dụ, templates
+
+**Quy tắc ngón tay cái:** Bắt đầu nhỏ, mở rộng dựa trên phản hồi.
+
+---
+
+## Thực hành Tốt nhất về Định dạng
+
+### Sử dụng Markdown Hiệu quả
+
+#### Khối Code (Code Blocks)
+
+Luôn chỉ định ngôn ngữ:
+
+```markdown
+\`\`\`javascript
+const example = "code";
+\`\`\`
+```
+
+#### Danh sách (Lists)
+
+Sử dụng định dạng nhất quán:
+
+```markdown
+- Mục 1
+- Mục 2
+  - Mục con 2.1
+  - Mục con 2.2
+```
+
+#### Nhấn mạnh (Emphasis)
+
+- **In đậm** cho các thuật ngữ quan trọng: `**quan trọng**`
+- _In nghiêng_ để nhấn mạnh: `*nhấn mạnh*`
+- `Code` cho lệnh hoặc code: `` `code` ``
+
+#### Liên kết (Links)
+
+```markdown
+[Văn bản liên kết](https://example.com)
+```
+
+---
+
+## ✅ Danh mục Kiểm tra Chất lượng (Quality Checklist)
+
+Trước khi hoàn tất skill của bạn:
+
+### Chất lượng Nội dung
+
+- [ ] Hướng dẫn rõ ràng và có thể thực hiện được.
+- [ ] Ví dụ thực tế và hữu ích.
+- [ ] Không có lỗi chính tả hoặc ngữ pháp.
+- [ ] Độ chính xác kỹ thuật đã được xác minh.
+
+### Cấu trúc
+
+- [ ] Frontmatter là YAML hợp lệ.
+- [ ] Tên (Name) khớp với tên thư mục.
+- [ ] Các phần được sắp xếp logic.
+- [ ] Các tiêu đề tuân thủ cấp bậc (H1 → H2 → H3).
+
+### Tính đầy đủ
+
+- [ ] Phần Tổng quan giải thích "tại sao".
+- [ ] Hướng dẫn giải thích "làm thế nào".
+- [ ] Ví dụ cho thấy "cái gì".
+- [ ] Các trường hợp biên (edge cases) được đề cập.
+
+### Khả năng sử dụng
+
+- [ ] Một người mới bắt đầu có thể làm theo.
+- [ ] Một chuyên gia thấy nó hữu ích.
+- [ ] AI có thể phân tích chính xác.
+- [ ] Nó giải quyết một vấn đề thực tế.
+
+---
+
+## 🔍 Phân tích Ví dụ Thực tế
+
+Hãy phân tích một skill thực tế: `brainstorming`
+
+```markdown
+---
+name: brainstorming
+description: "Bạn PHẢI sử dụng skill này trước bất kỳ công việc sáng tạo nào..."
+---
+```
+
+**Phân tích:**
+
+- ✅ Tên rõ ràng.
+- ✅ Mô tả mạnh mẽ với tính cấp bách ("PHẢI sử dụng").
+- ✅ Giải thích khi nào nên dùng.
+
+```markdown
+# Brainstorming Ý tưởng thành Thiết kế
+ 
+## Tổng quan
+ 
+Giúp chuyển đổi ý tưởng thành các thiết kế hoàn chỉnh...
+```
+
+**Phân tích:**
+
+- ✅ Tiêu đề rõ ràng.
+- ✅ Tổng quan súc tích.
+- ✅ Giải thích giá trị mang lại.
+
+```markdown
+## Quy trình
+ 
+**Hiểu ý tưởng:**
+ 
+- Kiểm tra trạng thái dự án hiện tại trước.
+- Đặt câu hỏi từng cái một.
+```
+
+**Phân tích:**
+
+- ✅ Được chia thành các giai đoạn rõ ràng.
+- ✅ Các bước cụ thể, có thể hành động.
+- ✅ Dễ dàng thực hiện theo.
+
+---
+
+## Các Mẫu Nâng cao
+
+### Logic có Điều kiện
+
+```markdown
+## Hướng dẫn
+ 
+Nếu người dùng đang làm việc với React:
+ 
+- Sử dụng functional components.
+- Ưu tiên hooks hơn class components.
+ 
+Nếu người dùng đang làm việc với Vue:
+ 
+- Sử dụng Composition API.
+- Tuân theo các mẫu của Vue 3.
+```
+
+### Tiết lộ Lũy tiến (Progressive Disclosure)
+
+```markdown
+## Cách dùng Cơ bản
+ 
+[Hướng dẫn đơn giản cho các trường hợp phổ biến]
+ 
+## Cách dùng Nâng cao
+ 
+[Các mẫu phức tạp cho người dùng chuyên sâu]
+```
+
+### Tham chiếu Chéo (Cross-References)
+
+```markdown
+## Các Luồng công việc liên quan
+ 
+1. Đầu tiên, dùng `@brainstorming` để thiết kế.
+2. Sau đó, dùng `@writing-plans` để lập kế hoạch.
+3. Cuối cùng, dùng `@test-driven-development` để triển khai.
+```
+
+---
+
+## Đo lường Hiệu quả của Skill
+
+Cách để biết skill của bạn có tốt hay không:
+
+### Kiểm tra Tính Rõ ràng
+
+- Người không quen thuộc với chủ đề có thể làm theo không?
+- Có hướng dẫn nào mơ hồ không?
+
+### Kiểm tra Tính Đầy đủ
+
+- Nó có bao quát trường hợp thuận lợi (happy path) không?
+- Nó có xử lý các trường hợp biên không?
+- Các kịch bản lỗi đã được giải quyết chưa?
+
+### Kiểm tra Tính Hữu ích
+
+- Nó có giải quyết một vấn đề thực tế không?
+- Chính bạn có sử dụng nó không?
+- Nó có giúp tiết kiệm thời gian hoặc cải thiện chất lượng không?
+
+---
+
+## Học hỏi từ các Skill hiện có
+
+### Nghiên cứu các Ví dụ sau
+
+**Dành cho Người mới:**
+
+- `skills/brainstorming/SKILL.md` - Cấu trúc rõ ràng.
+- `skills/git-pushing/SKILL.md` - Đơn giản và tập trung.
+- `skills/copywriting/SKILL.md` - Ví dụ tốt.
+
+**Dành cho Nâng cao:**
+
+- `skills/systematic-debugging/SKILL.md` - Toàn diện.
+- `skills/react-best-practices/SKILL.md` - Nhiều file.
+- `skills/loki-mode/SKILL.md` - Các luồng công việc phức tạp.
+
+---
+
+## 💡 Mẹo Chuyên nghiệp
+
+1. **Bắt đầu với phần "Khi nào sử dụng"** - Điều này làm rõ mục đích của skill.
+2. **Viết ví dụ trước** - Chúng giúp bạn hiểu những gì bạn đang dạy.
+3. **Kiểm tra với AI** - Xem liệu nó có thực sự hoạt động trước khi gửi.
+4. **Nhận phản hồi** - Nhờ người khác xem qua skill của bạn.
+5. **Cải thiện liên tục** - Skill sẽ tốt lên theo thời gian dựa trên việc sử dụng.
+
+---
+
+## Các lỗi Thường gặp cần Tránh
+
+### ❌ Lỗi 1: Quá mơ hồ
+
+```markdown
+## Hướng dẫn
+ 
+Làm cho code tốt hơn.
+```
+
+**✅ Khắc phục:**
+
+```markdown
+## Hướng dẫn
+ 
+1. Tách các logic lặp lại thành các hàm.
+2. Thêm xử lý lỗi cho các trường hợp biên.
+3. Viết unit tests cho các chức năng cốt lõi.
+```
+
+### ❌ Lỗi 2: Quá phức tạp
+
+```markdown
+## Hướng dẫn
+ 
+[5000 từ chứa đầy thuật ngữ kỹ thuật dày đặc]
+```
+
+**✅ Khắc phục:**
+Chia nhỏ thành nhiều skill hoặc sử dụng phương pháp tiết lộ lũy tiến.
+
+### ❌ Lỗi 3: Không có ví dụ
+
+```markdown
+## Hướng dẫn
+ 
+[Hướng dẫn mà không có bất kỳ ví dụ code nào]
+```
+
+**✅ Khắc phục:**
+Thêm ít nhất 2-3 ví dụ thực tế.
+
+### ❌ Lỗi 4: Thông tin lỗi thời
+
+```markdown
+Sử dụng React class components...
+```
+
+**✅ Khắc phục:**
+Luôn cập nhật skill với các thực hành tốt nhất hiện tại.
+
+---
+
+## 🎯 Các bước Tiếp theo
+
+1. **Đọc 3-5 skill hiện có** để thấy các phong cách khác nhau.
+2. **Thử dùng bản mẫu skill** từ file `CONTRIBUTING.md`.
+3. **Tạo một skill đơn giản** cho lĩnh vực bạn am hiểu.
+4. **Kiểm tra nó** với trợ lý AI của bạn.
+5. **Chia sẻ nó** qua Pull Request.
+
+---
+
+**Hãy nhớ rằng:** Mọi chuyên gia đều từng là người mới bắt đầu. Hãy bắt đầu đơn giản, học hỏi từ phản hồi và cải thiện theo thời gian! 🚀

docs/vietnamese/SOURCES.vi.md

@@ -0,0 +1,21 @@
+# 📜 Nguồn gốc & Ghi công
+
+Chúng tôi tin tưởng vào việc ghi nhận công sức một cách xứng đáng.  
+Nếu bạn nhận ra tác phẩm của mình ở đây mà chưa được ghi công đúng cách, vui lòng mở một Issue (Báo lỗi).
+
+| Kỹ năng / Danh mục          | Nguồn gốc                                              | Giấy phép      | Ghi chú                       |
+| :-------------------------- | :----------------------------------------------------- | :------------- | :---------------------------- |
+| `cloud-penetration-testing` | [HackTricks](https://book.hacktricks.xyz/)             | MIT / CC-BY-SA | Được chuyển đổi cho trợ lý AI.|
+| `active-directory-attacks`  | [HackTricks](https://book.hacktricks.xyz/)             | MIT / CC-BY-SA | Được chuyển đổi cho trợ lý AI.|
+| `owasp-top-10`              | [OWASP](https://owasp.org/)                            | CC-BY-SA       | Chuyển đổi từ phương pháp gốc.|
+| `burp-suite-testing`        | [PortSwigger](https://portswigger.net/burp)            | Không có       | Chỉ là hướng dẫn sử dụng.     |
+| `crewai`                    | [CrewAI](https://github.com/joaomdmoura/crewAI)        | MIT            | Hướng dẫn về framework.       |
+| `langgraph`                 | [LangGraph](https://github.com/langchain-ai/langgraph) | MIT            | Hướng dẫn về framework.       |
+| `react-patterns`            | [React Docs](https://react.dev/)                       | CC-BY          | Các mẫu thiết kế chính thức.  |
+| **Tất cả Skill Chính thức** | [Anthropic / Google / OpenAI]                          | Bản quyền riêng| Được khuyến khích bởi nhà CC. |
+
+## Chính sách Giấy phép
+
+- **Mã nguồn (Code)**: Tất cả mã nguồn gốc trong repository này tuân theo giấy phép **MIT**.
+- **Nội dung (Content)**: Tài liệu hướng dẫn tuân theo giấy phép **CC-BY-4.0**.
+- **Bên thứ ba**: Chúng tôi tôn trọng giấy phép từ phía nguồn gốc của các tài liệu. Nếu một kỹ năng được nhập về có giấy phép GPL, nó sẽ được đánh dấu rõ ràng hoặc bị loại trừ (chúng tôi hướng tới sự tương thích với MIT/Apache).

docs/vietnamese/TRANSLATION_PLAN.vi.md

@@ -0,0 +1,65 @@
+# 🗺️ Kế hoạch Dịch thuật (Translation Master Plan)
+
+Tài liệu này dùng để theo dõi tiến độ dịch thuật toàn bộ repository `antigravity-awesome-skills` sang tiếng Việt.
+
+**Mục tiêu:** Dịch toàn bộ 552+ kỹ năng và tài liệu hướng dẫn.
+**Quy tắc:**
+1. Giữ nguyên cấu trúc thư mục gốc.
+2. File dịch được lưu tại `docs/vietnamese/skills/<category>/<skill-name>.vi.md`.
+3. Sử dụng văn phong chuyên nghiệp, dễ hiểu cho lập trình viên Việt Nam.
+
+---
+
+## 📊 Tổng quan Tiến độ
+
+- [x] **Giai đoạn 0: Thiết lập & Core Docs** (README, CONTRIBUTING, v.v.)
+- [x] **Giai đoạn 1: Essentials Bundle** (Các kỹ năng cốt lõi)
+- [ ] **Giai đoạn 2: Development & Security** (Kỹ năng lập trình & bảo mật)
+- [ ] **Giai đoạn 3: Data & AI, Infrastructure** (Dữ liệu, AI và Hạ tầng)
+- [ ] **Giai đoạn 4: Architecture & General** (Kiến trúc & Các kỹ năng chung)
+- [ ] **Giai đoạn 5: Business, Testing & Workflow** (Kinh doanh, Kiểm thử & Quy trình)
+
+---
+
+## ✅ Chi tiết Công việc
+
+### 🟢 Giai đoạn 0: Tài liệu Gốc (Core Documentation)
+
+- [x] `README.vi.md`
+- [x] `docs/vietnamese/BUNDLES.vi.md`
+- [x] `docs/vietnamese/CONTRIBUTING.vi.md`
+- [x] `docs/vietnamese/EXAMPLES.vi.md`
+- [x] `docs/vietnamese/FAQ.vi.md`
+- [x] `docs/vietnamese/GETTING_STARTED.vi.md`
+- [x] `docs/vietnamese/QUALITY_BAR.vi.md`
+- [x] `docs/vietnamese/SECURITY_GUARDRAILS.vi.md`
+- [x] `docs/vietnamese/SKILL_ANATOMY.vi.md`
+- [x] `docs/vietnamese/SOURCES.vi.md`
+- [x] `docs/vietnamese/VISUAL_GUIDE.vi.md`
+- [x] `docs/vietnamese/SECURITY.vi.md`
+- [x] `docs/vietnamese/SKILLS_README.vi.md`
+
+### 🟢 Giai đoạn 1: Essentials Bundle (Core Skills)
+> **TRẠNG THÁI: GIỮ NGUYÊN TIẾNG ANH (KEPT IN ENGLISH)**
+> *Lý do: Các file Skill đóng vai trò là System Prompts cho AI Agent. Việc dịch sang tiếng Việt có thể làm giảm hiệu suất và độ chính xác của Agent.*
+
+### 🟡 Giai đoạn 2 - 5: All Other Skills
+> **TRẠNG THÁI: GIỮ NGUYÊN TIẾNG ANH (KEPT IN ENGLISH)**
+> *Lý do: Tương tự như trên, giữ nguyên bản gốc để đảm bảo tính tương thích tốt nhất với các mô hình AI.*
+
+---
+
+## 🎯 Kết luận
+- **Phần dành cho Con người (Human-facing Docs):** Đã dịch hoàn tất (`README`, `DOCS`, v.v.).
+- **Phần dành cho AI (Agent Skills):** Giữ nguyên Tiếng Anh.
+
+Dự án đã đạt trạng thái sẵn sàng sử dụng cho người dùng Việt Nam (với tài liệu hướng dẫn tiếng Việt) mà vẫn đảm bảo sức mạnh cốt lõi của Agent (với Skills tiếng Anh).
+
+---
+
+## 📝 Nhật ký Thay đổi (Changelog)
+
+- **2026-01-29**:
+  - Hoàn thành Giai đoạn 0 (Docs).
+  - Hoàn thành Giai đoạn 1 (Essentials).
+  - Cấu trúc lại repo: Chuyển toàn bộ bản dịch vào `docs/vietnamese/`.

docs/vietnamese/VISUAL_GUIDE.vi.md

@@ -0,0 +1,512 @@
+# Hướng dẫn Nhanh bằng Hình ảnh (Visual Guide)
+
+**Học qua hình ảnh!** Hướng dẫn này sử dụng các sơ đồ và ví dụ trực quan để giúp bạn hiểu về các kỹ năng (skills).
+
+---
+
+## Cái nhìn Tổng quan
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                       BẠN (Lập trình viên)                  │
+│                          ↓                                  │
+│              "Giúp tôi xây dựng hệ thống thanh toán"        │
+│                          ↓                                  │
+├─────────────────────────────────────────────────────────────┤
+│                  TRỢ LÝ AI (AI ASSISTANT)                   │
+│                          ↓                                  │
+│              Tải kỹ năng @stripe-integration                │
+│                          ↓                                  │
+│         Trở thành chuyên gia về thanh toán Stripe           │
+│                          ↓                                  │
+│    Cung cấp hỗ trợ chuyên sâu kèm các ví dụ code            │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 📦 Cấu trúc Repository (Trực quan)
+
+```
+antigravity-awesome-skills/
+│
+├── 📄 README.md                    ← Tổng quan & danh sách skill
+├── 📄 CONTRIBUTING.md              ← Cách thức đóng góp
+│
+├── 📁 skills/                      ← Nơi chứa tất cả hơn 250 skills
+│   │
+│   ├── 📁 brainstorming/
+│   │   └── 📄 SKILL.md             ← Định nghĩa skill
+│   │
+│   ├── 📁 stripe-integration/
+│   │   ├── 📄 SKILL.md
+│   │   └── 📁 examples/            ← Các phần bổ sung tùy chọn
+│   │
+│   └── ... (Hơn 250 skills khác)
+│
+├── 📁 scripts/                     ← Quản lý & Xác thực
+│   ├── validate_skills.py          ← Công cụ kiểm soát chất lượng
+│   └── generate_index.py           ← Công cụ tạo danh mục (registry)
+│
+├── 📁 .github/
+│   └── 📄 MAINTENANCE.md           ← Hướng dẫn cho người duy trì
+│
+└── 📁 docs/                        ← Tài liệu hướng dẫn
+    ├── 📄 GETTING_STARTED.md       ← Bắt đầu tại đây! (MỚI)
+    ├── 📄 FAQ.md                   ← Giải đáp thắc mắc
+    ├── 📄 BUNDLES.md               ← Gói khởi đầu (MỚI)
+    ├── 📄 QUALITY_BAR.md           ← Tiêu chuẩn chất lượng
+    ├── 📄 SKILL_ANATOMY.md         ← Cách thức skill hoạt động
+    └── 📄 VISUAL_GUIDE.md          ← Chính là file này!
+```
+
+---
+
+## Cách Skills Hoạt động (Sơ đồ Luồng)
+
+```
+┌──────────────┐
+│ 1. CÀI ĐẶT   │  Sao chép skills vào .agent/skills/
+1 └──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 2. GỌI LỆNH  │  Gõ: @ten-skill trong chat với AI
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 3. TẢI DỮ LIỆU│  AI đọc file SKILL.md
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 4. THỰC THI  │  AI tuân theo hướng dẫn trong skill
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 5. KẾT QUẢ   │  Bạn nhận được hỗ trợ chuyên sâu!
+└──────────────┘
+```
+
+---
+
+## 🎯 Phân loại Skills (Bản đồ Trực quan)
+
+```
+                    ┌─────────────────────────┐
+                    │   250+ AWESOME SKILLS   │
+                    └────────────┬────────────┘
+                                 │
+        ┌────────────────────────┼────────────────────────┐
+        │                        │                        │
+   ┌────▼────┐            ┌──────▼──────┐         ┌──────▼──────┐
+   │ SÁNG TẠO│            │ PHÁT TRIỂN  │         │  BẢO MẬT    │
+   │ (10)    │            │    (25)     │         │    (50)     │
+   └────┬────┘            └──────┬──────┘         └──────┬──────┘
+        │                        │                        │
+   • Thiết kế UI/UX        • TDD                    • Hacking Đạo đức
+   • Nghệ thuật Canvas     • Debugging              • Metasploit
+   • Giao diện/Themes      • Mẫu thiết kế React     • Burp Suite
+                                                    • SQLMap
+         │                        │                        │
+         └────────────────────────┼────────────────────────┘
+                                 │
+        ┌────────────────────────┼────────────────────────┐
+        │                        │                        │
+   ┌────▼────┐            ┌──────▼──────┐         ┌──────▼──────┐
+   │   AI    │            │  TÀI LIỆU   │         │  MARKETING  │
+   │  (30)   │            │     (4)     │         │    (23)     │
+   └────┬────┘            └──────┬──────┘         └──────┬──────┘
+        │                        │                        │
+   • Hệ thống RAG          • DOCX                   • SEO
+   • LangGraph             • PDF                    • Copywriting
+   • Prompt Eng.           • PPTX                   • CRO
+   • Voice Agents          • XLSX                   • Quảng cáo trả phí
+```
+
+---
+
+## Cấu trúc File Skill (Trực quan)
+
+````
+┌─────────────────────────────────────────────────────────┐
+│ SKILL.md                                                │
+├─────────────────────────────────────────────────────────┤
+│                                                         │
+│  ┌───────────────────────────────────────────────┐     │
+│  │ FRONTMATTER (Siêu dữ liệu)                    │     │
+│  │ ───────────────────────────────────────────── │     │
+│  │ ---                                           │     │
+│  │ name: my-skill                                │     │
+│  │ description: "Công dụng của skill này"        │     │
+│  │ ---                                           │     │
+│  └───────────────────────────────────────────────┘     │
+│                                                         │
+│  ┌───────────────────────────────────────────────┐     │
+│  │ NỘI DUNG (Hướng dẫn)                          │     │
+│  │ ───────────────────────────────────────────── │     │
+│  │                                               │     │
+│  │ # Tiêu đề Skill                               │     │
+│  │                                               │     │
+│  │ ## Tổng quan                                  │     │
+│  │ Skill này làm gì...                           │     │
+│  │                                               │     │
+│  │ ## Khi nào nên dùng                           │     │
+│  │ - Sử dụng khi...                              │     │
+│  │                                               │     │
+│  │ ## Hướng dẫn                                  │     │
+│  │ 1. Bước đầu tiên...                           │     │
+│  │ 2. Bước thứ hai...                            │     │
+│  │                                               │     │
+│  │ ## Ví dụ                                      │     │
+│  │ ```javascript                                 │     │
+│  │ // Code ví dụ                                 │     │
+│  │ ```                                           │     │
+│  │                                               │     │
+│  └───────────────────────────────────────────────┘     │
+│                                                         │
+└─────────────────────────────────────────────────────────┘
+````
+
+---
+
+## Cài đặt (Các bước Trực quan)
+
+### Bước 1: Sao chép Repository
+
+```
+┌─────────────────────────────────────────┐
+│ Terminal                                │
+├─────────────────────────────────────────┤
+│ $ git clone https://github.com/        │
+│   sickn33/antigravity-awesome-skills    │
+│   .agent/skills                         │
+│                                         │
+│ ✓ Đang sao chép vào '.agent/skills'... │
+│ ✓ Hoàn tất!                             │
+└─────────────────────────────────────────┘
+```
+
+### Bước 2: Xác minh Cài đặt
+
+```
+┌─────────────────────────────────────────┐
+│ File Explorer                           │
+├─────────────────────────────────────────┤
+│ 📁 .agent/                              │
+│   └── 📁 skills/                        │
+│       ├── 📁 brainstorming/             │
+│       ├── 📁 stripe-integration/        │
+│       ├── 📁 react-best-practices/      │
+│       └── ... (Thêm 176 mục nữa)        │
+└─────────────────────────────────────────┘
+```
+
+### Bước 3: Sử dụng Skill
+
+```
+┌─────────────────────────────────────────┐
+│ AI Assistant Chat                       │
+├─────────────────────────────────────────┤
+│ Bạn: @brainstorming giúp tôi thiết kế   │
+│      một ứng dụng todo                  │
+│                                         │
+│ AI:  Tuyệt vời! Hãy để tôi giúp bạn suy │
+│      nghĩ kỹ về việc này. Đầu tiên, hãy │
+│      tìm hiểu các yêu cầu của bạn...    │
+│                                         │
+│      Mục đích sử dụng chính là gì?      │
+│      a) Quản lý công việc cá nhân       │
+│      b) Hợp tác nhóm                    │
+│      c) Lập kế hoạch dự án              │
+└─────────────────────────────────────────┘
+```
+
+---
+
+## Ví dụ: Sử dụng Skill (Từng bước)
+
+### Tình huống: Bạn muốn thêm thanh toán Stripe vào ứng dụng của mình
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ BƯỚC 1: Xác định Nhu cầu                                    │
+├─────────────────────────────────────────────────────────────┤
+│ "Tôi cần thêm xử lý thanh toán vào ứng dụng của mình"       │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ BƯỚC 2: Tìm đúng Skill                                      │
+├─────────────────────────────────────────────────────────────┤
+│ Tìm kiếm: "payment" hoặc "stripe"                           │
+│ Tìm thấy: @stripe-integration                               │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ BƯỚC 3: Gọi lệnh Skill                                      │
+├─────────────────────────────────────────────────────────────┤
+│ Bạn: @stripe-integration giúp tôi thêm thanh toán định kỳ   │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ BƯỚC 4: AI Tải Kiến thức của Skill                          │
+├─────────────────────────────────────────────────────────────┤
+│ • Các mẫu Stripe API                                        │
+│ • Xử lý Webhook                                             │
+│ • Quản lý gói đăng ký (Subscription)                        │
+│ • Thực hành tốt nhất                                        │
+└─────────────────────────────────────────────────────────────┘
+                          ↓
+┌─────────────────────────────────────────────────────────────┐
+│ BƯỚC 5: Nhận Hỗ trợ Chuyên gia                              │
+├─────────────────────────────────────────────────────────────┤
+│ AI cung cấp:                                                │
+│ • Các ví dụ code                                            │
+│ • Hướng dẫn thiết lập                                       │
+│ • Các lưu ý về bảo mật                                      │
+│ • Chiến lược kiểm thử                                       │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Tìm kiếm Skills (Hướng dẫn Trực quan)
+
+### Cách 1: Duyệt theo Danh mục
+
+```
+README.md → Cuộn xuống "Full Skill Registry" → Tìm danh mục → Chọn skill
+```
+
+### Cách 2: Tìm theo Từ khóa
+
+```
+Terminal → ls skills/ | grep "từ-khóa" → Xem các skill khớp
+```
+
+### Cách 3: Sử dụng Index
+
+```
+Mở file skills_index.json → Tìm từ khóa → Tìm đường dẫn đến skill
+```
+
+---
+
+## Tạo Skill đầu tiên của bạn (Quy trình Trực quan)
+
+```
+┌──────────────┐
+│ 1. Ý TƯỞNG   │  "Tôi muốn chia sẻ kiến thức về Docker"
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 2. KHỞI TẠO  │  mkdir skills/docker-mastery
+└──────┬───────┘  touch skills/docker-mastery/SKILL.md
+       │
+       ↓
+┌──────────────┐
+│ 3. VIẾT      │  Thêm frontmatter + nội dung
+└──────┬───────┘  (Dùng template từ CONTRIBUTING.vi.md)
+       │
+       ↓
+┌──────────────┐
+│ 4. KIỂM THỬ  │  Sao chép vào .agent/skills/
+└──────┬───────┘  Thử: @docker-mastery
+       │
+       ↓
+┌──────────────┐
+│ 5. XÁC THỰC  │  python3 scripts/validate_skills.py
+└──────┬───────┘
+       │
+       ↓
+┌──────────────┐
+│ 6. GỬI ĐI    │  git commit + push + Pull Request
+└──────────────┘
+```
+
+---
+
+## Các Cấp độ Phức tạp của Skill
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    ĐỘ PHỨC TẠP CỦA SKILL                    │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  ĐƠN GIẢN                  TIÊU CHUẨN            PHỨC TẠP   │
+│  ────────                  ──────────            ────────   │
+│                                                             │
+│  • 1 file                  • 1 file              • Nhiều file│
+│  • 100-200 từ              • 300-800 từ          • 800-2000 từ│
+│  • Cấu trúc cơ bản         • Cấu trúc đầy đủ     • Có scripts │
+│  • Không có phần phụ       • Có ví dụ            • Có ví dụ   │
+│                            • Thực hành tốt nhất  • Có template│
+│                                                  • Có tài liệu│
+│  Ví dụ:                    Ví dụ:                Ví dụ:       │
+│  git-pushing               brainstorming         loki-mode    │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🎯 Tác động của việc Đóng góp (Trực quan)
+
+```
+Sự đóng góp của bạn
+       │
+       ├─→ Cải thiện tài liệu hướng dẫn
+       │        │
+       │        └─→ Giúp hàng ngàn dev dễ hiểu hơn
+       │
+       ├─→ Tạo ra Skill mới
+       │        │
+       │        └─→ Mang lại khả năng mới cho mọi người
+       │
+       ├─→ Sửa lỗi/Lỗi chính tả
+       │        │
+       │        └─→ Tránh hiểu lầm cho người dùng tương lai
+       │
+       └─→ Thêm ví dụ
+                │
+                └─→ Giúp người mới học dễ dàng hơn
+```
+
+---
+
+## Lộ trình Học tập (Roadmap Trực quan)
+
+```
+BẮT ĐẦU TẠI ĐÂY
+    │
+    ↓
+┌─────────────────┐
+│ Đọc             │
+│ GETTING_STARTED │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Thử dùng 2-3 Skill│
+│ với Trợ lý AI   │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Đọc             │
+│ SKILL_ANATOMY   │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Nghiên cứu      │
+│ Skills hiện có  │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Tạo Skill       │
+│ đơn giản        │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Đọc             │
+│ CONTRIBUTING    │
+└────────┬────────┘
+         │
+         ↓
+┌─────────────────┐
+│ Gửi PR          │
+└────────┬────────┘
+         │
+         ↓
+ TRỞ THÀNH CONTRIBUTOR! 🎉
+```
+
+---
+
+## 💡 Mẹo Nhanh (Bản ghi chú Trực quan)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      THAM KHẢO NHANH                        │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  📥 CÀI ĐẶT                                                 │
+│  git clone [repo] .agent/skills                             │
+│                                                             │
+│  🎯 SỬ DỤNG                                                 │
+│  @ten-skill [yêu cầu của bạn]                               │
+│                                                             │
+│  🔍 TÌM KIẾM                                                │
+│  ls skills/ | grep "từ-khóa"                                │
+│                                                             │
+│  ✅ XÁC THỰC                                                │
+│  python3 scripts/validate_skills.py                         │
+│                                                             │
+│  📝 TẠO SKILL                                               │
+│  1. mkdir skills/ten-skill-cua-ban                          │
+│  2. Tạo SKILL.md với frontmatter                            │
+│  3. Thêm nội dung                                           │
+│  4. Thử nghiệm & xác thực                                   │
+│  5. Gửi Pull Request (PR)                                   │
+│                                                             │
+│  🆘 TRỢ GIÚP                                                │
+│  • docs/GETTING_STARTED.md - Cơ bản                         │
+│  • CONTRIBUTING.md - Cách đóng góp                          │
+│  • SKILL_ANATOMY.md - Tìm hiểu sâu                          │
+│  • GitHub Issues - Đặt câu hỏi                              │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Câu chuyện Thành công (Dòng thời gian Trực quan)
+
+```
+Ngày 1: Cài đặt skills
+  │
+  └─→ "Oa, @brainstorming đã giúp mình thiết kế ứng dụng!"
+
+Ngày 3: Dùng 5 skills khác nhau
+  │
+  └─→ "Những kỹ năng này giúp mình tiết kiệm bao nhiêu thời gian!"
+
+Tuần 1: Tạo skill đầu tiên
+  │
+  └─→ "Mình đã chia sẻ kiến thức của mình dưới dạng một skill!"
+
+Tuần 2: Skill được gộp (merge) vào máy chủ
+  │
+  └─→ "Kỹ năng của mình đang giúp đỡ người khác! 🎉"
+
+Tháng 1: Trở thành người đóng góp thường xuyên
+  │
+  └─→ "Mình đã đóng góp 5 skills và cải thiện rất nhiều tài liệu!"
+```
+
+---
+
+## Các Bước Tiếp theo
+
+1. ✅ **Hiểu** cấu trúc trực quan.
+2. ✅ **Cài đặt** skills vào công cụ AI của bạn.
+3. ✅ **Thử dùng** 2-3 skills từ các danh mục khác nhau.
+4. ✅ **Đọc** file CONTRIBUTING.md.
+5. ✅ **Tạo** skill đầu tiên của bạn.
+6. ✅ **Chia sẻ** với cộng đồng.
+
+---
+
+**Bạn là người học qua hình ảnh?** Hy vọng hướng dẫn này sẽ giúp ích! Bạn vẫn còn thắc mắc? Hãy kiểm tra:
+
+- [GETTING_STARTED.md](GETTING_STARTED.vi.md) - Giới thiệu bằng văn bản.
+- [SKILL_ANATOMY.md](SKILL_ANATOMY.vi.md) - Phân tích chi tiết.
+- [CONTRIBUTING.md](../CONTRIBUTING.vi.md) - Cách thức đóng góp.
+
+**Sẵn sàng đóng góp?** Bạn làm được mà! 💪

lib/skill-utils.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('yaml');
+
+function stripQuotes(value) {
+  if (typeof value !== 'string') return value;
+  if (value.length < 2) return value.trim();
+  const first = value[0];
+  const last = value[value.length - 1];
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return value.slice(1, -1).trim();
+  }
+  if (first === '"' || first === "'") {
+    return value.slice(1).trim();
+  }
+  if (last === '"' || last === "'") {
+    return value.slice(0, -1).trim();
+  }
+  return value.trim();
+}
+
+function parseInlineList(raw) {
+  if (typeof raw !== 'string') return [];
+  const value = raw.trim();
+  if (!value.startsWith('[') || !value.endsWith(']')) return [];
+  const inner = value.slice(1, -1).trim();
+  if (!inner) return [];
+  return inner
+    .split(',')
+    .map(item => stripQuotes(item.trim()))
+    .filter(Boolean);
+}
+
+function isPlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseFrontmatter(content) {
+  const sanitized = content.replace(/^\uFEFF/, '');
+  const lines = sanitized.split(/\r?\n/);
+  if (!lines.length || lines[0].trim() !== '---') {
+    return { data: {}, body: content, errors: [], hasFrontmatter: false };
+  }
+
+  let endIndex = -1;
+  for (let i = 1; i < lines.length; i += 1) {
+    if (lines[i].trim() === '---') {
+      endIndex = i;
+      break;
+    }
+  }
+
+  if (endIndex === -1) {
+    return {
+      data: {},
+      body: content,
+      errors: ['Missing closing frontmatter delimiter (---).'],
+      hasFrontmatter: true,
+    };
+  }
+
+  const errors = [];
+  const fmText = lines.slice(1, endIndex).join('\n');
+  let data = {};
+
+  try {
+    const doc = yaml.parseDocument(fmText, { prettyErrors: false });
+    if (doc.errors && doc.errors.length) {
+      errors.push(...doc.errors.map(error => error.message));
+    }
+    data = doc.toJS();
+  } catch (err) {
+    errors.push(err.message);
+    data = {};
+  }
+
+  if (!isPlainObject(data)) {
+    errors.push('Frontmatter must be a YAML mapping/object.');
+    data = {};
+  }
+
+  const body = lines.slice(endIndex + 1).join('\n');
+  return { data, body, errors, hasFrontmatter: true };
+}
+
+function tokenize(value) {
+  if (!value) return [];
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .split(' ')
+    .map(token => token.trim())
+    .filter(Boolean);
+}
+
+function unique(list) {
+  const seen = new Set();
+  const result = [];
+  for (const item of list) {
+    if (!item || seen.has(item)) continue;
+    seen.add(item);
+    result.push(item);
+  }
+  return result;
+}
+
+function readSkill(skillDir, skillId) {
+  const skillPath = path.join(skillDir, skillId, 'SKILL.md');
+  const content = fs.readFileSync(skillPath, 'utf8');
+  const { data } = parseFrontmatter(content);
+  const name = typeof data.name === 'string' && data.name.trim()
+    ? data.name.trim()
+    : skillId;
+  const description = typeof data.description === 'string'
+    ? data.description.trim()
+    : '';
+
+  let tags = [];
+  if (Array.isArray(data.tags)) {
+    tags = data.tags.map(tag => String(tag).trim());
+  } else if (typeof data.tags === 'string' && data.tags.trim()) {
+    const parts = data.tags.includes(',')
+      ? data.tags.split(',')
+      : data.tags.split(/\s+/);
+    tags = parts.map(tag => tag.trim());
+  } else if (isPlainObject(data.metadata) && data.metadata.tags) {
+    const rawTags = data.metadata.tags;
+    if (Array.isArray(rawTags)) {
+      tags = rawTags.map(tag => String(tag).trim());
+    } else if (typeof rawTags === 'string' && rawTags.trim()) {
+      const parts = rawTags.includes(',')
+        ? rawTags.split(',')
+        : rawTags.split(/\s+/);
+      tags = parts.map(tag => tag.trim());
+    }
+  }
+
+  tags = tags.filter(Boolean);
+
+  return {
+    id: skillId,
+    name,
+    description,
+    tags,
+    path: skillPath,
+    content,
+  };
+}
+
+function listSkillIds(skillsDir) {
+  return fs.readdirSync(skillsDir)
+    .filter(entry => !entry.startsWith('.') && fs.statSync(path.join(skillsDir, entry)).isDirectory())
+    .sort();
+}
+
+module.exports = {
+  listSkillIds,
+  parseFrontmatter,
+  parseInlineList,
+  readSkill,
+  stripQuotes,
+  tokenize,
+  unique,
+};

node_modules/.bin/yaml

@@ -0,0 +1 @@
+../yaml/bin.mjs

node_modules/.package-lock.json

@@ -0,0 +1,22 @@
+{
+  "name": "antigravity-awesome-skills",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/yaml": {
+      "version": "2.8.2",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
+      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
+      }
+    }
+  }
+}

node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

node_modules/yaml/README.md

@@ -0,0 +1,172 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a definitive library for [YAML](https://yaml.org/), the human friendly data serialization standard.
+This library:
+
+- Supports both YAML 1.1 and YAML 1.2 and all common data schemas,
+- Passes all of the [yaml-test-suite](https://github.com/yaml/yaml-test-suite) tests,
+- Can accept any string as input without throwing, parsing as much YAML out of it as it can, and
+- Supports parsing, modifying, and writing YAML comments and blank lines.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/).
+It has no external dependencies and runs on Node.js as well as modern browsers.
+
+For the purposes of versioning, any changes that break any of the documented endpoints or APIs will be considered semver-major breaking changes.
+Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+The minimum supported TypeScript version of the included typings is 3.9;
+for use in earlier versions you may need to set `skipLibCheck: true` in your config.
+This requirement may be updated between minor versions of the library.
+
+For more information, see the project's documentation site: [**eemeli.org/yaml**](https://eemeli.org/yaml/)
+
+For build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+To install:
+
+```sh
+npm install yaml
+# or
+deno add jsr:@eemeli/yaml
+```
+
+**Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the underlying [Lexer/Parser/Composer](https://eemeli.org/yaml/#parsing-yaml).
+The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing.
+
+A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
+
+### Parse & Stringify
+
+```js
+import { parse, stringify } from 'yaml'
+```
+
+- [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
+- [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
+
+### Documents
+
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
+- [`Document`](https://eemeli.org/yaml/#documents)
+  - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
+  - [`#contents`](https://eemeli.org/yaml/#content-nodes)
+  - [`#directives`](https://eemeli.org/yaml/#stream-directives)
+  - [`#errors`](https://eemeli.org/yaml/#errors)
+  - [`#warnings`](https://eemeli.org/yaml/#errors)
+- [`isDocument(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`parseAllDocuments(str, options?): Document[]`](https://eemeli.org/yaml/#parsing-documents)
+- [`parseDocument(str, options?): Document`](https://eemeli.org/yaml/#parsing-documents)
+
+### Content Nodes
+
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
+- [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isNode(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isPair(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isScalar(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isSeq(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
+- [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
+- [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+
+### Parsing YAML
+
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: |
+//   two
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" alt="BrowserStack" />
+</a>

node_modules/yaml/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})

node_modules/yaml/browser/dist/compose/compose-collection.js

@@ -0,0 +1,88 @@
+import { isNode } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveBlockMap } from './resolve-block-map.js';
+import { resolveBlockSeq } from './resolve-block-seq.js';
+import { resolveFlowCollection } from './resolve-flow-collection.js';
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt?.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = isNode(res)
+        ? res
+        : new Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+export { composeCollection };

node_modules/yaml/browser/dist/compose/compose-doc.js

@@ -0,0 +1,43 @@
+import { Document } from '../doc/Document.js';
+import { composeNode, composeEmptyNode } from './compose-node.js';
+import { resolveEnd } from './resolve-end.js';
+import { resolveProps } from './resolve-props.js';
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document(undefined, opts);
+    const ctx = {
+        atKey: false,
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps(start, {
+        indicator: 'doc-start',
+        next: value ?? end?.[0],
+        offset,
+        onError,
+        parentIndent: 0,
+        startOnNewline: true
+    });
+    if (props.found) {
+        doc.directives.docStart = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
+    // @ts-expect-error If Contents is set, let's trust the user
+    doc.contents = value
+        ? composeNode(ctx, value, props, onError)
+        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+export { composeDoc };

node_modules/yaml/browser/dist/compose/compose-node.js

@@ -0,0 +1,102 @@
+import { Alias } from '../nodes/Alias.js';
+import { isScalar } from '../nodes/identity.js';
+import { composeCollection } from './compose-collection.js';
+import { composeScalar } from './compose-scalar.js';
+import { resolveEnd } from './resolve-end.js';
+import { emptyScalarPosition } from './util-empty-scalar-position.js';
+
+const CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+    const atKey = ctx.atKey;
+    const { spaceBefore, comment, anchor, tag } = props;
+    let node;
+    let isSrcToken = true;
+    switch (token.type) {
+        case 'alias':
+            node = composeAlias(ctx, token, onError);
+            if (anchor || tag)
+                onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties');
+            break;
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'block-scalar':
+            node = composeScalar(ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        case 'block-map':
+        case 'block-seq':
+        case 'flow-collection':
+            node = composeCollection(CN, ctx, token, props, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        default: {
+            const message = token.type === 'error'
+                ? token.message
+                : `Unsupported token (type: ${token.type})`;
+            onError(token, 'UNEXPECTED_TOKEN', message);
+            node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError);
+            isSrcToken = false;
+        }
+    }
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    if (atKey &&
+        ctx.options.stringKeys &&
+        (!isScalar(node) ||
+            typeof node.value !== 'string' ||
+            (node.tag && node.tag !== 'tag:yaml.org,2002:str'))) {
+        const msg = 'With stringKeys, all keys must be strings';
+        onError(tag ?? token, 'NON_STRING_KEY', msg);
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        if (token.type === 'scalar' && token.source === '')
+            node.comment = comment;
+        else
+            node.commentBefore = comment;
+    }
+    // @ts-expect-error Type checking misses meaning of isSrcToken
+    if (ctx.options.keepSourceTokens && isSrcToken)
+        node.srcToken = token;
+    return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+    const token = {
+        type: 'scalar',
+        offset: emptyScalarPosition(offset, before, pos),
+        indent: -1,
+        source: ''
+    };
+    const node = composeScalar(ctx, token, tag, onError);
+    if (anchor) {
+        node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        node.comment = comment;
+        node.range[2] = end;
+    }
+    return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+    const alias = new Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
+    if (alias.source.endsWith(':'))
+        onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
+    if (re.comment)
+        alias.comment = re.comment;
+    return alias;
+}
+
+export { composeEmptyNode, composeNode };

node_modules/yaml/browser/dist/compose/compose-scalar.js

@@ -0,0 +1,86 @@
+import { isScalar, SCALAR } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { resolveBlockScalar } from './resolve-block-scalar.js';
+import { resolveFlowScalar } from './resolve-flow-scalar.js';
+
+function composeScalar(ctx, token, tagToken, onError) {
+    const { value, type, comment, range } = token.type === 'block-scalar'
+        ? resolveBlockScalar(ctx, token, onError)
+        : resolveFlowScalar(token, ctx.options.strict, onError);
+    const tagName = tagToken
+        ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
+        : null;
+    let tag;
+    if (ctx.options.stringKeys && ctx.atKey) {
+        tag = ctx.schema[SCALAR];
+    }
+    else if (tagName)
+        tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+    else if (token.type === 'scalar')
+        tag = findScalarTagByTest(ctx, value, token, onError);
+    else
+        tag = ctx.schema[SCALAR];
+    let scalar;
+    try {
+        const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+        scalar = isScalar(res) ? res : new Scalar(res);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg);
+        scalar = new Scalar(value);
+    }
+    scalar.range = range;
+    scalar.source = value;
+    if (type)
+        scalar.type = type;
+    if (tagName)
+        scalar.tag = tagName;
+    if (tag.format)
+        scalar.format = tag.format;
+    if (comment)
+        scalar.comment = comment;
+    return scalar;
+}
+function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+    if (tagName === '!')
+        return schema[SCALAR]; // non-specific tag
+    const matchWithTest = [];
+    for (const tag of schema.tags) {
+        if (!tag.collection && tag.tag === tagName) {
+            if (tag.default && tag.test)
+                matchWithTest.push(tag);
+            else
+                return tag;
+        }
+    }
+    for (const tag of matchWithTest)
+        if (tag.test?.test(value))
+            return tag;
+    const kt = schema.knownTags[tagName];
+    if (kt && !kt.collection) {
+        // Ensure that the known tag is available for stringifying,
+        // but does not get used by default.
+        schema.tags.push(Object.assign({}, kt, { default: false, test: undefined }));
+        return kt;
+    }
+    onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
+    return schema[SCALAR];
+}
+function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
+    const tag = schema.tags.find(tag => (tag.default === true || (atKey && tag.default === 'key')) &&
+        tag.test?.test(value)) || schema[SCALAR];
+    if (schema.compat) {
+        const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
+            schema[SCALAR];
+        if (tag.tag !== compat.tag) {
+            const ts = directives.tagString(tag.tag);
+            const cs = directives.tagString(compat.tag);
+            const msg = `Value may be parsed as either ${ts} or ${cs}`;
+            onError(token, 'TAG_RESOLVE_FAILED', msg, true);
+        }
+    }
+    return tag;
+}
+
+export { composeScalar };

node_modules/yaml/browser/dist/compose/composer.js

@@ -0,0 +1,217 @@
+import { Directives } from '../doc/directives.js';
+import { Document } from '../doc/Document.js';
+import { YAMLWarning, YAMLParseError } from '../errors.js';
+import { isCollection, isPair } from '../nodes/identity.js';
+import { composeDoc } from './compose-doc.js';
+import { resolveEnd } from './resolve-end.js';
+
+function getErrorPos(src) {
+    if (typeof src === 'number')
+        return [src, src + 1];
+    if (Array.isArray(src))
+        return src.length === 2 ? src : [src[0], src[1]];
+    const { offset, source } = src;
+    return [offset, offset + (typeof source === 'string' ? source.length : 1)];
+}
+function parsePrelude(prelude) {
+    let comment = '';
+    let atComment = false;
+    let afterEmptyLine = false;
+    for (let i = 0; i < prelude.length; ++i) {
+        const source = prelude[i];
+        switch (source[0]) {
+            case '#':
+                comment +=
+                    (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
+                        (source.substring(1) || ' ');
+                atComment = true;
+                afterEmptyLine = false;
+                break;
+            case '%':
+                if (prelude[i + 1]?.[0] !== '#')
+                    i += 1;
+                atComment = false;
+                break;
+            default:
+                // This may be wrong after doc-end, but in that case it doesn't matter
+                if (!atComment)
+                    afterEmptyLine = true;
+                atComment = false;
+        }
+    }
+    return { comment, afterEmptyLine };
+}
+/**
+ * Compose a stream of CST nodes into a stream of YAML Documents.
+ *
+ * ```ts
+ * import { Composer, Parser } from 'yaml'
+ *
+ * const src: string = ...
+ * const tokens = new Parser().parse(src)
+ * const docs = new Composer().compose(tokens)
+ * ```
+ */
+class Composer {
+    constructor(options = {}) {
+        this.doc = null;
+        this.atDirectives = false;
+        this.prelude = [];
+        this.errors = [];
+        this.warnings = [];
+        this.onError = (source, code, message, warning) => {
+            const pos = getErrorPos(source);
+            if (warning)
+                this.warnings.push(new YAMLWarning(pos, code, message));
+            else
+                this.errors.push(new YAMLParseError(pos, code, message));
+        };
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        this.directives = new Directives({ version: options.version || '1.2' });
+        this.options = options;
+    }
+    decorate(doc, afterDoc) {
+        const { comment, afterEmptyLine } = parsePrelude(this.prelude);
+        //console.log({ dc: doc.comment, prelude, comment })
+        if (comment) {
+            const dc = doc.contents;
+            if (afterDoc) {
+                doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment;
+            }
+            else if (afterEmptyLine || doc.directives.docStart || !dc) {
+                doc.commentBefore = comment;
+            }
+            else if (isCollection(dc) && !dc.flow && dc.items.length > 0) {
+                let it = dc.items[0];
+                if (isPair(it))
+                    it = it.key;
+                const cb = it.commentBefore;
+                it.commentBefore = cb ? `${comment}\n${cb}` : comment;
+            }
+            else {
+                const cb = dc.commentBefore;
+                dc.commentBefore = cb ? `${comment}\n${cb}` : comment;
+            }
+        }
+        if (afterDoc) {
+            Array.prototype.push.apply(doc.errors, this.errors);
+            Array.prototype.push.apply(doc.warnings, this.warnings);
+        }
+        else {
+            doc.errors = this.errors;
+            doc.warnings = this.warnings;
+        }
+        this.prelude = [];
+        this.errors = [];
+        this.warnings = [];
+    }
+    /**
+     * Current stream status information.
+     *
+     * Mostly useful at the end of input for an empty stream.
+     */
+    streamInfo() {
+        return {
+            comment: parsePrelude(this.prelude).comment,
+            directives: this.directives,
+            errors: this.errors,
+            warnings: this.warnings
+        };
+    }
+    /**
+     * Compose tokens into documents.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    *compose(tokens, forceDoc = false, endOffset = -1) {
+        for (const token of tokens)
+            yield* this.next(token);
+        yield* this.end(forceDoc, endOffset);
+    }
+    /** Advance the composer by one CST token. */
+    *next(token) {
+        switch (token.type) {
+            case 'directive':
+                this.directives.add(token.source, (offset, message, warning) => {
+                    const pos = getErrorPos(token);
+                    pos[0] += offset;
+                    this.onError(pos, 'BAD_DIRECTIVE', message, warning);
+                });
+                this.prelude.push(token.source);
+                this.atDirectives = true;
+                break;
+            case 'document': {
+                const doc = composeDoc(this.options, this.directives, token, this.onError);
+                if (this.atDirectives && !doc.directives.docStart)
+                    this.onError(token, 'MISSING_CHAR', 'Missing directives-end/doc-start indicator line');
+                this.decorate(doc, false);
+                if (this.doc)
+                    yield this.doc;
+                this.doc = doc;
+                this.atDirectives = false;
+                break;
+            }
+            case 'byte-order-mark':
+            case 'space':
+                break;
+            case 'comment':
+            case 'newline':
+                this.prelude.push(token.source);
+                break;
+            case 'error': {
+                const msg = token.source
+                    ? `${token.message}: ${JSON.stringify(token.source)}`
+                    : token.message;
+                const error = new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg);
+                if (this.atDirectives || !this.doc)
+                    this.errors.push(error);
+                else
+                    this.doc.errors.push(error);
+                break;
+            }
+            case 'doc-end': {
+                if (!this.doc) {
+                    const msg = 'Unexpected doc-end without preceding document';
+                    this.errors.push(new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
+                    break;
+                }
+                this.doc.directives.docEnd = true;
+                const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+                this.decorate(this.doc, true);
+                if (end.comment) {
+                    const dc = this.doc.comment;
+                    this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment;
+                }
+                this.doc.range[2] = end.offset;
+                break;
+            }
+            default:
+                this.errors.push(new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', `Unsupported token ${token.type}`));
+        }
+    }
+    /**
+     * Call at end of input to yield any remaining document.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    *end(forceDoc = false, endOffset = -1) {
+        if (this.doc) {
+            this.decorate(this.doc, true);
+            yield this.doc;
+            this.doc = null;
+        }
+        else if (forceDoc) {
+            const opts = Object.assign({ _directives: this.directives }, this.options);
+            const doc = new Document(undefined, opts);
+            if (this.atDirectives)
+                this.onError(endOffset, 'MISSING_CHAR', 'Missing directives-end indicator line');
+            doc.range = [0, endOffset, endOffset];
+            this.decorate(doc, false);
+            yield doc;
+        }
+    }
+}
+
+export { Composer };

node_modules/yaml/browser/dist/compose/resolve-block-map.js

@@ -0,0 +1,115 @@
+import { Pair } from '../nodes/Pair.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { resolveProps } from './resolve-props.js';
+import { containsNewline } from './util-contains-newline.js';
+import { flowIndentCheck } from './util-flow-indent-check.js';
+import { mapIncludes } from './util-map-includes.js';
+
+const startColMsg = 'All mapping items must start at the same column';
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLMap;
+    const map = new NodeClass(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
+    let offset = bm.offset;
+    let commentEnd = null;
+    for (const collItem of bm.items) {
+        const { start, key, sep, value } = collItem;
+        // key properties
+        const keyProps = resolveProps(start, {
+            indicator: 'explicit-key-ind',
+            next: key ?? sep?.[0],
+            offset,
+            onError,
+            parentIndent: bm.indent,
+            startOnNewline: true
+        });
+        const implicitKey = !keyProps.found;
+        if (implicitKey) {
+            if (key) {
+                if (key.type === 'block-seq')
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'A block sequence may not be used as an implicit map key');
+                else if ('indent' in key && key.indent !== bm.indent)
+                    onError(offset, 'BAD_INDENT', startColMsg);
+            }
+            if (!keyProps.anchor && !keyProps.tag && !sep) {
+                commentEnd = keyProps.end;
+                if (keyProps.comment) {
+                    if (map.comment)
+                        map.comment += '\n' + keyProps.comment;
+                    else
+                        map.comment = keyProps.comment;
+                }
+                continue;
+            }
+            if (keyProps.newlineAfterProp || containsNewline(key)) {
+                onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
+            }
+        }
+        else if (keyProps.found?.indent !== bm.indent) {
+            onError(offset, 'BAD_INDENT', startColMsg);
+        }
+        // key value
+        ctx.atKey = true;
+        const keyStart = keyProps.end;
+        const keyNode = key
+            ? composeNode(ctx, key, keyProps, onError)
+            : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+        if (ctx.schema.compat)
+            flowIndentCheck(bm.indent, key, onError);
+        ctx.atKey = false;
+        if (mapIncludes(ctx, map.items, keyNode))
+            onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+        // value properties
+        const valueProps = resolveProps(sep ?? [], {
+            indicator: 'map-value-ind',
+            next: value,
+            offset: keyNode.range[2],
+            onError,
+            parentIndent: bm.indent,
+            startOnNewline: !key || key.type === 'block-scalar'
+        });
+        offset = valueProps.end;
+        if (valueProps.found) {
+            if (implicitKey) {
+                if (value?.type === 'block-map' && !valueProps.hasNewline)
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'Nested mappings are not allowed in compact mappings');
+                if (ctx.options.strict &&
+                    keyProps.start < valueProps.found.offset - 1024)
+                    onError(keyNode.range, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key');
+            }
+            // value value
+            const valueNode = value
+                ? composeNode(ctx, value, valueProps, onError)
+                : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+            if (ctx.schema.compat)
+                flowIndentCheck(bm.indent, value, onError);
+            offset = valueNode.range[2];
+            const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
+        }
+        else {
+            // key with no value
+            if (implicitKey)
+                onError(keyNode.range, 'MISSING_CHAR', 'Implicit map keys need to be followed by map values');
+            if (valueProps.comment) {
+                if (keyNode.comment)
+                    keyNode.comment += '\n' + valueProps.comment;
+                else
+                    keyNode.comment = valueProps.comment;
+            }
+            const pair = new Pair(keyNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
+        }
+    }
+    if (commentEnd && commentEnd < offset)
+        onError(commentEnd, 'IMPOSSIBLE', 'Map comment with trailing content');
+    map.range = [bm.offset, offset, commentEnd ?? offset];
+    return map;
+}
+
+export { resolveBlockMap };

node_modules/yaml/browser/dist/compose/resolve-block-scalar.js

@@ -0,0 +1,198 @@
+import { Scalar } from '../nodes/Scalar.js';
+
+function resolveBlockScalar(ctx, scalar, onError) {
+    const start = scalar.offset;
+    const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
+    if (!header)
+        return { value: '', type: null, comment: '', range: [start, start, start] };
+    const type = header.mode === '>' ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
+    const lines = scalar.source ? splitLines(scalar.source) : [];
+    // determine the end of content & start of chomping
+    let chompStart = lines.length;
+    for (let i = lines.length - 1; i >= 0; --i) {
+        const content = lines[i][1];
+        if (content === '' || content === '\r')
+            chompStart = i;
+        else
+            break;
+    }
+    // shortcut for empty contents
+    if (chompStart === 0) {
+        const value = header.chomp === '+' && lines.length > 0
+            ? '\n'.repeat(Math.max(1, lines.length - 1))
+            : '';
+        let end = start + header.length;
+        if (scalar.source)
+            end += scalar.source.length;
+        return { value, type, comment: header.comment, range: [start, end, end] };
+    }
+    // find the indentation level to trim from start
+    let trimIndent = scalar.indent + header.indent;
+    let offset = scalar.offset + header.length;
+    let contentStart = 0;
+    for (let i = 0; i < chompStart; ++i) {
+        const [indent, content] = lines[i];
+        if (content === '' || content === '\r') {
+            if (header.indent === 0 && indent.length > trimIndent)
+                trimIndent = indent.length;
+        }
+        else {
+            if (indent.length < trimIndent) {
+                const message = 'Block scalars with more-indented leading empty lines must use an explicit indentation indicator';
+                onError(offset + indent.length, 'MISSING_CHAR', message);
+            }
+            if (header.indent === 0)
+                trimIndent = indent.length;
+            contentStart = i;
+            if (trimIndent === 0 && !ctx.atRoot) {
+                const message = 'Block scalar values in collections must be indented';
+                onError(offset, 'BAD_INDENT', message);
+            }
+            break;
+        }
+        offset += indent.length + content.length + 1;
+    }
+    // include trailing more-indented empty lines in content
+    for (let i = lines.length - 1; i >= chompStart; --i) {
+        if (lines[i][0].length > trimIndent)
+            chompStart = i + 1;
+    }
+    let value = '';
+    let sep = '';
+    let prevMoreIndented = false;
+    // leading whitespace is kept intact
+    for (let i = 0; i < contentStart; ++i)
+        value += lines[i][0].slice(trimIndent) + '\n';
+    for (let i = contentStart; i < chompStart; ++i) {
+        let [indent, content] = lines[i];
+        offset += indent.length + content.length + 1;
+        const crlf = content[content.length - 1] === '\r';
+        if (crlf)
+            content = content.slice(0, -1);
+        /* istanbul ignore if already caught in lexer */
+        if (content && indent.length < trimIndent) {
+            const src = header.indent
+                ? 'explicit indentation indicator'
+                : 'first line';
+            const message = `Block scalar lines must not be less indented than their ${src}`;
+            onError(offset - content.length - (crlf ? 2 : 1), 'BAD_INDENT', message);
+            indent = '';
+        }
+        if (type === Scalar.BLOCK_LITERAL) {
+            value += sep + indent.slice(trimIndent) + content;
+            sep = '\n';
+        }
+        else if (indent.length > trimIndent || content[0] === '\t') {
+            // more-indented content within a folded block
+            if (sep === ' ')
+                sep = '\n';
+            else if (!prevMoreIndented && sep === '\n')
+                sep = '\n\n';
+            value += sep + indent.slice(trimIndent) + content;
+            sep = '\n';
+            prevMoreIndented = true;
+        }
+        else if (content === '') {
+            // empty line
+            if (sep === '\n')
+                value += '\n';
+            else
+                sep = '\n';
+        }
+        else {
+            value += sep + content;
+            sep = ' ';
+            prevMoreIndented = false;
+        }
+    }
+    switch (header.chomp) {
+        case '-':
+            break;
+        case '+':
+            for (let i = chompStart; i < lines.length; ++i)
+                value += '\n' + lines[i][0].slice(trimIndent);
+            if (value[value.length - 1] !== '\n')
+                value += '\n';
+            break;
+        default:
+            value += '\n';
+    }
+    const end = start + header.length + scalar.source.length;
+    return { value, type, comment: header.comment, range: [start, end, end] };
+}
+function parseBlockScalarHeader({ offset, props }, strict, onError) {
+    /* istanbul ignore if should not happen */
+    if (props[0].type !== 'block-scalar-header') {
+        onError(props[0], 'IMPOSSIBLE', 'Block scalar header not found');
+        return null;
+    }
+    const { source } = props[0];
+    const mode = source[0];
+    let indent = 0;
+    let chomp = '';
+    let error = -1;
+    for (let i = 1; i < source.length; ++i) {
+        const ch = source[i];
+        if (!chomp && (ch === '-' || ch === '+'))
+            chomp = ch;
+        else {
+            const n = Number(ch);
+            if (!indent && n)
+                indent = n;
+            else if (error === -1)
+                error = offset + i;
+        }
+    }
+    if (error !== -1)
+        onError(error, 'UNEXPECTED_TOKEN', `Block scalar header includes extra characters: ${source}`);
+    let hasSpace = false;
+    let comment = '';
+    let length = source.length;
+    for (let i = 1; i < props.length; ++i) {
+        const token = props[i];
+        switch (token.type) {
+            case 'space':
+                hasSpace = true;
+            // fallthrough
+            case 'newline':
+                length += token.source.length;
+                break;
+            case 'comment':
+                if (strict && !hasSpace) {
+                    const message = 'Comments must be separated from other tokens by white space characters';
+                    onError(token, 'MISSING_CHAR', message);
+                }
+                length += token.source.length;
+                comment = token.source.substring(1);
+                break;
+            case 'error':
+                onError(token, 'UNEXPECTED_TOKEN', token.message);
+                length += token.source.length;
+                break;
+            /* istanbul ignore next should not happen */
+            default: {
+                const message = `Unexpected token in block scalar header: ${token.type}`;
+                onError(token, 'UNEXPECTED_TOKEN', message);
+                const ts = token.source;
+                if (ts && typeof ts === 'string')
+                    length += ts.length;
+            }
+        }
+    }
+    return { mode, indent, chomp, comment, length };
+}
+/** @returns Array of lines split up as `[indent, content]` */
+function splitLines(source) {
+    const split = source.split(/\n( *)/);
+    const first = split[0];
+    const m = first.match(/^( *)/);
+    const line0 = m?.[1]
+        ? [m[1], first.slice(m[1].length)]
+        : ['', first];
+    const lines = [line0];
+    for (let i = 1; i < split.length; i += 2)
+        lines.push([split[i], split[i + 1]]);
+    return lines;
+}
+
+export { resolveBlockScalar };

node_modules/yaml/browser/dist/compose/resolve-block-seq.js

@@ -0,0 +1,49 @@
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveProps } from './resolve-props.js';
+import { flowIndentCheck } from './util-flow-indent-check.js';
+
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLSeq;
+    const seq = new NodeClass(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
+    if (ctx.atKey)
+        ctx.atKey = false;
+    let offset = bs.offset;
+    let commentEnd = null;
+    for (const { start, value } of bs.items) {
+        const props = resolveProps(start, {
+            indicator: 'seq-item-ind',
+            next: value,
+            offset,
+            onError,
+            parentIndent: bs.indent,
+            startOnNewline: true
+        });
+        if (!props.found) {
+            if (props.anchor || props.tag || value) {
+                if (value?.type === 'block-seq')
+                    onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column');
+                else
+                    onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
+            }
+            else {
+                commentEnd = props.end;
+                if (props.comment)
+                    seq.comment = props.comment;
+                continue;
+            }
+        }
+        const node = value
+            ? composeNode(ctx, value, props, onError)
+            : composeEmptyNode(ctx, props.end, start, null, props, onError);
+        if (ctx.schema.compat)
+            flowIndentCheck(bs.indent, value, onError);
+        offset = node.range[2];
+        seq.items.push(node);
+    }
+    seq.range = [bs.offset, offset, commentEnd ?? offset];
+    return seq;
+}
+
+export { resolveBlockSeq };

node_modules/yaml/browser/dist/compose/resolve-end.js

@@ -0,0 +1,37 @@
+function resolveEnd(end, offset, reqSpace, onError) {
+    let comment = '';
+    if (end) {
+        let hasSpace = false;
+        let sep = '';
+        for (const token of end) {
+            const { source, type } = token;
+            switch (type) {
+                case 'space':
+                    hasSpace = true;
+                    break;
+                case 'comment': {
+                    if (reqSpace && !hasSpace)
+                        onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                    const cb = source.substring(1) || ' ';
+                    if (!comment)
+                        comment = cb;
+                    else
+                        comment += sep + cb;
+                    sep = '';
+                    break;
+                }
+                case 'newline':
+                    if (comment)
+                        sep += source;
+                    hasSpace = true;
+                    break;
+                default:
+                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${type} at node end`);
+            }
+            offset += source.length;
+        }
+    }
+    return { comment, offset };
+}
+
+export { resolveEnd };

node_modules/yaml/browser/dist/compose/resolve-flow-collection.js

@@ -0,0 +1,207 @@
+import { isPair } from '../nodes/identity.js';
+import { Pair } from '../nodes/Pair.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveEnd } from './resolve-end.js';
+import { resolveProps } from './resolve-props.js';
+import { containsNewline } from './util-contains-newline.js';
+import { mapIncludes } from './util-map-includes.js';
+
+const blockMsg = 'Block collections are not allowed within flow collections';
+const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
+    const isMap = fc.start.source === '{';
+    const fcName = isMap ? 'flow map' : 'flow sequence';
+    const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq));
+    const coll = new NodeClass(ctx.schema);
+    coll.flow = true;
+    const atRoot = ctx.atRoot;
+    if (atRoot)
+        ctx.atRoot = false;
+    if (ctx.atKey)
+        ctx.atKey = false;
+    let offset = fc.offset + fc.start.source.length;
+    for (let i = 0; i < fc.items.length; ++i) {
+        const collItem = fc.items[i];
+        const { start, key, sep, value } = collItem;
+        const props = resolveProps(start, {
+            flow: fcName,
+            indicator: 'explicit-key-ind',
+            next: key ?? sep?.[0],
+            offset,
+            onError,
+            parentIndent: fc.indent,
+            startOnNewline: false
+        });
+        if (!props.found) {
+            if (!props.anchor && !props.tag && !sep && !value) {
+                if (i === 0 && props.comma)
+                    onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
+                else if (i < fc.items.length - 1)
+                    onError(props.start, 'UNEXPECTED_TOKEN', `Unexpected empty item in ${fcName}`);
+                if (props.comment) {
+                    if (coll.comment)
+                        coll.comment += '\n' + props.comment;
+                    else
+                        coll.comment = props.comment;
+                }
+                offset = props.end;
+                continue;
+            }
+            if (!isMap && ctx.options.strict && containsNewline(key))
+                onError(key, // checked by containsNewline()
+                'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+        }
+        if (i === 0) {
+            if (props.comma)
+                onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
+        }
+        else {
+            if (!props.comma)
+                onError(props.start, 'MISSING_CHAR', `Missing , between ${fcName} items`);
+            if (props.comment) {
+                let prevItemComment = '';
+                loop: for (const st of start) {
+                    switch (st.type) {
+                        case 'comma':
+                        case 'space':
+                            break;
+                        case 'comment':
+                            prevItemComment = st.source.substring(1);
+                            break loop;
+                        default:
+                            break loop;
+                    }
+                }
+                if (prevItemComment) {
+                    let prev = coll.items[coll.items.length - 1];
+                    if (isPair(prev))
+                        prev = prev.value ?? prev.key;
+                    if (prev.comment)
+                        prev.comment += '\n' + prevItemComment;
+                    else
+                        prev.comment = prevItemComment;
+                    props.comment = props.comment.substring(prevItemComment.length + 1);
+                }
+            }
+        }
+        if (!isMap && !sep && !props.found) {
+            // item is a value in a seq
+            // → key & sep are empty, start does not include ? or :
+            const valueNode = value
+                ? composeNode(ctx, value, props, onError)
+                : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+            coll.items.push(valueNode);
+            offset = valueNode.range[2];
+            if (isBlock(value))
+                onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+        }
+        else {
+            // item is a key+value pair
+            // key value
+            ctx.atKey = true;
+            const keyStart = props.end;
+            const keyNode = key
+                ? composeNode(ctx, key, props, onError)
+                : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+            if (isBlock(key))
+                onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            ctx.atKey = false;
+            // value properties
+            const valueProps = resolveProps(sep ?? [], {
+                flow: fcName,
+                indicator: 'map-value-ind',
+                next: value,
+                offset: keyNode.range[2],
+                onError,
+                parentIndent: fc.indent,
+                startOnNewline: false
+            });
+            if (valueProps.found) {
+                if (!isMap && !props.found && ctx.options.strict) {
+                    if (sep)
+                        for (const st of sep) {
+                            if (st === valueProps.found)
+                                break;
+                            if (st.type === 'newline') {
+                                onError(st, 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+                                break;
+                            }
+                        }
+                    if (props.start < valueProps.found.offset - 1024)
+                        onError(valueProps.found, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key');
+                }
+            }
+            else if (value) {
+                if ('source' in value && value.source?.[0] === ':')
+                    onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`);
+                else
+                    onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`);
+            }
+            // value value
+            const valueNode = value
+                ? composeNode(ctx, value, valueProps, onError)
+                : valueProps.found
+                    ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError)
+                    : null;
+            if (valueNode) {
+                if (isBlock(value))
+                    onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            }
+            else if (valueProps.comment) {
+                if (keyNode.comment)
+                    keyNode.comment += '\n' + valueProps.comment;
+                else
+                    keyNode.comment = valueProps.comment;
+            }
+            const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            if (isMap) {
+                const map = coll;
+                if (mapIncludes(ctx, map.items, keyNode))
+                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+                map.items.push(pair);
+            }
+            else {
+                const map = new YAMLMap(ctx.schema);
+                map.flow = true;
+                map.items.push(pair);
+                const endRange = (valueNode ?? keyNode).range;
+                map.range = [keyNode.range[0], endRange[1], endRange[2]];
+                coll.items.push(map);
+            }
+            offset = valueNode ? valueNode.range[2] : valueProps.end;
+        }
+    }
+    const expectedEnd = isMap ? '}' : ']';
+    const [ce, ...ee] = fc.end;
+    let cePos = offset;
+    if (ce?.source === expectedEnd)
+        cePos = ce.offset + ce.source.length;
+    else {
+        const name = fcName[0].toUpperCase() + fcName.substring(1);
+        const msg = atRoot
+            ? `${name} must end with a ${expectedEnd}`
+            : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+        onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg);
+        if (ce && ce.source.length !== 1)
+            ee.unshift(ce);
+    }
+    if (ee.length > 0) {
+        const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+        if (end.comment) {
+            if (coll.comment)
+                coll.comment += '\n' + end.comment;
+            else
+                coll.comment = end.comment;
+        }
+        coll.range = [fc.offset, cePos, end.offset];
+    }
+    else {
+        coll.range = [fc.offset, cePos, cePos];
+    }
+    return coll;
+}
+
+export { resolveFlowCollection };

node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js

@@ -0,0 +1,223 @@
+import { Scalar } from '../nodes/Scalar.js';
+import { resolveEnd } from './resolve-end.js';
+
+function resolveFlowScalar(scalar, strict, onError) {
+    const { offset, type, source, end } = scalar;
+    let _type;
+    let value;
+    const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+    switch (type) {
+        case 'scalar':
+            _type = Scalar.PLAIN;
+            value = plainValue(source, _onError);
+            break;
+        case 'single-quoted-scalar':
+            _type = Scalar.QUOTE_SINGLE;
+            value = singleQuotedValue(source, _onError);
+            break;
+        case 'double-quoted-scalar':
+            _type = Scalar.QUOTE_DOUBLE;
+            value = doubleQuotedValue(source, _onError);
+            break;
+        /* istanbul ignore next should not happen */
+        default:
+            onError(scalar, 'UNEXPECTED_TOKEN', `Expected a flow scalar value, but found: ${type}`);
+            return {
+                value: '',
+                type: null,
+                comment: '',
+                range: [offset, offset + source.length, offset + source.length]
+            };
+    }
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, strict, onError);
+    return {
+        value,
+        type: _type,
+        comment: re.comment,
+        range: [offset, valueEnd, re.offset]
+    };
+}
+function plainValue(source, onError) {
+    let badChar = '';
+    switch (source[0]) {
+        /* istanbul ignore next should not happen */
+        case '\t':
+            badChar = 'a tab character';
+            break;
+        case ',':
+            badChar = 'flow indicator character ,';
+            break;
+        case '%':
+            badChar = 'directive indicator character %';
+            break;
+        case '|':
+        case '>': {
+            badChar = `block scalar indicator ${source[0]}`;
+            break;
+        }
+        case '@':
+        case '`': {
+            badChar = `reserved character ${source[0]}`;
+            break;
+        }
+    }
+    if (badChar)
+        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
+    return foldLines(source);
+}
+function singleQuotedValue(source, onError) {
+    if (source[source.length - 1] !== "'" || source.length === 1)
+        onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
+    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+}
+function foldLines(source) {
+    /**
+     * The negative lookbehind here and in the `re` RegExp is to
+     * prevent causing a polynomial search time in certain cases.
+     *
+     * The try-catch is for Safari, which doesn't support this yet:
+     * https://caniuse.com/js-regexp-lookbehind
+     */
+    let first, line;
+    try {
+        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
+        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+    }
+    catch {
+        first = /(.*?)[ \t]*\r?\n/sy;
+        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+    }
+    let match = first.exec(source);
+    if (!match)
+        return source;
+    let res = match[1];
+    let sep = ' ';
+    let pos = first.lastIndex;
+    line.lastIndex = pos;
+    while ((match = line.exec(source))) {
+        if (match[1] === '') {
+            if (sep === '\n')
+                res += sep;
+            else
+                sep = '\n';
+        }
+        else {
+            res += sep + match[1];
+            sep = ' ';
+        }
+        pos = line.lastIndex;
+    }
+    const last = /[ \t]*(.*)/sy;
+    last.lastIndex = pos;
+    match = last.exec(source);
+    return res + sep + (match?.[1] ?? '');
+}
+function doubleQuotedValue(source, onError) {
+    let res = '';
+    for (let i = 1; i < source.length - 1; ++i) {
+        const ch = source[i];
+        if (ch === '\r' && source[i + 1] === '\n')
+            continue;
+        if (ch === '\n') {
+            const { fold, offset } = foldNewline(source, i);
+            res += fold;
+            i = offset;
+        }
+        else if (ch === '\\') {
+            let next = source[++i];
+            const cc = escapeCodes[next];
+            if (cc)
+                res += cc;
+            else if (next === '\n') {
+                // skip escaped newlines, but still trim the following line
+                next = source[i + 1];
+                while (next === ' ' || next === '\t')
+                    next = source[++i + 1];
+            }
+            else if (next === '\r' && source[i + 1] === '\n') {
+                // skip escaped CRLF newlines, but still trim the following line
+                next = source[++i + 1];
+                while (next === ' ' || next === '\t')
+                    next = source[++i + 1];
+            }
+            else if (next === 'x' || next === 'u' || next === 'U') {
+                const length = { x: 2, u: 4, U: 8 }[next];
+                res += parseCharCode(source, i + 1, length, onError);
+                i += length;
+            }
+            else {
+                const raw = source.substr(i - 1, 2);
+                onError(i - 1, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
+                res += raw;
+            }
+        }
+        else if (ch === ' ' || ch === '\t') {
+            // trim trailing whitespace
+            const wsStart = i;
+            let next = source[i + 1];
+            while (next === ' ' || next === '\t')
+                next = source[++i + 1];
+            if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n'))
+                res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
+        }
+        else {
+            res += ch;
+        }
+    }
+    if (source[source.length - 1] !== '"' || source.length === 1)
+        onError(source.length, 'MISSING_CHAR', 'Missing closing "quote');
+    return res;
+}
+/**
+ * Fold a single newline into a space, multiple newlines to N - 1 newlines.
+ * Presumes `source[offset] === '\n'`
+ */
+function foldNewline(source, offset) {
+    let fold = '';
+    let ch = source[offset + 1];
+    while (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+        if (ch === '\r' && source[offset + 2] !== '\n')
+            break;
+        if (ch === '\n')
+            fold += '\n';
+        offset += 1;
+        ch = source[offset + 1];
+    }
+    if (!fold)
+        fold = ' ';
+    return { fold, offset };
+}
+const escapeCodes = {
+    '0': '\0', // null character
+    a: '\x07', // bell character
+    b: '\b', // backspace
+    e: '\x1b', // escape character
+    f: '\f', // form feed
+    n: '\n', // line feed
+    r: '\r', // carriage return
+    t: '\t', // horizontal tab
+    v: '\v', // vertical tab
+    N: '\u0085', // Unicode next line
+    _: '\u00a0', // Unicode non-breaking space
+    L: '\u2028', // Unicode line separator
+    P: '\u2029', // Unicode paragraph separator
+    ' ': ' ',
+    '"': '"',
+    '/': '/',
+    '\\': '\\',
+    '\t': '\t'
+};
+function parseCharCode(source, offset, length, onError) {
+    const cc = source.substr(offset, length);
+    const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
+    const code = ok ? parseInt(cc, 16) : NaN;
+    if (isNaN(code)) {
+        const raw = source.substr(offset - 2, length + 2);
+        onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
+        return raw;
+    }
+    return String.fromCodePoint(code);
+}
+
+export { resolveFlowScalar };

node_modules/yaml/browser/dist/compose/resolve-props.js

@@ -0,0 +1,146 @@
+function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
+    let spaceBefore = false;
+    let atNewline = startOnNewline;
+    let hasSpace = startOnNewline;
+    let comment = '';
+    let commentSep = '';
+    let hasNewline = false;
+    let reqSpace = false;
+    let tab = null;
+    let anchor = null;
+    let tag = null;
+    let newlineAfterProp = null;
+    let comma = null;
+    let found = null;
+    let start = null;
+    for (const token of tokens) {
+        if (reqSpace) {
+            if (token.type !== 'space' &&
+                token.type !== 'newline' &&
+                token.type !== 'comma')
+                onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+            reqSpace = false;
+        }
+        if (tab) {
+            if (atNewline && token.type !== 'comment' && token.type !== 'newline') {
+                onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
+            }
+            tab = null;
+        }
+        switch (token.type) {
+            case 'space':
+                // At the doc level, tabs at line start may be parsed
+                // as leading white space rather than indentation.
+                // In a flow collection, only the parser handles indent.
+                if (!flow &&
+                    (indicator !== 'doc-start' || next?.type !== 'flow-collection') &&
+                    token.source.includes('\t')) {
+                    tab = token;
+                }
+                hasSpace = true;
+                break;
+            case 'comment': {
+                if (!hasSpace)
+                    onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                const cb = token.source.substring(1) || ' ';
+                if (!comment)
+                    comment = cb;
+                else
+                    comment += commentSep + cb;
+                commentSep = '';
+                atNewline = false;
+                break;
+            }
+            case 'newline':
+                if (atNewline) {
+                    if (comment)
+                        comment += token.source;
+                    else if (!found || indicator !== 'seq-item-ind')
+                        spaceBefore = true;
+                }
+                else
+                    commentSep += token.source;
+                atNewline = true;
+                hasNewline = true;
+                if (anchor || tag)
+                    newlineAfterProp = token;
+                hasSpace = true;
+                break;
+            case 'anchor':
+                if (anchor)
+                    onError(token, 'MULTIPLE_ANCHORS', 'A node can have at most one anchor');
+                if (token.source.endsWith(':'))
+                    onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true);
+                anchor = token;
+                start ?? (start = token.offset);
+                atNewline = false;
+                hasSpace = false;
+                reqSpace = true;
+                break;
+            case 'tag': {
+                if (tag)
+                    onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag');
+                tag = token;
+                start ?? (start = token.offset);
+                atNewline = false;
+                hasSpace = false;
+                reqSpace = true;
+                break;
+            }
+            case indicator:
+                // Could here handle preceding comments differently
+                if (anchor || tag)
+                    onError(token, 'BAD_PROP_ORDER', `Anchors and tags must be after the ${token.source} indicator`);
+                if (found)
+                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.source} in ${flow ?? 'collection'}`);
+                found = token;
+                atNewline =
+                    indicator === 'seq-item-ind' || indicator === 'explicit-key-ind';
+                hasSpace = false;
+                break;
+            case 'comma':
+                if (flow) {
+                    if (comma)
+                        onError(token, 'UNEXPECTED_TOKEN', `Unexpected , in ${flow}`);
+                    comma = token;
+                    atNewline = false;
+                    hasSpace = false;
+                    break;
+                }
+            // else fallthrough
+            default:
+                onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.type} token`);
+                atNewline = false;
+                hasSpace = false;
+        }
+    }
+    const last = tokens[tokens.length - 1];
+    const end = last ? last.offset + last.source.length : offset;
+    if (reqSpace &&
+        next &&
+        next.type !== 'space' &&
+        next.type !== 'newline' &&
+        next.type !== 'comma' &&
+        (next.type !== 'scalar' || next.source !== '')) {
+        onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+    }
+    if (tab &&
+        ((atNewline && tab.indent <= parentIndent) ||
+            next?.type === 'block-map' ||
+            next?.type === 'block-seq'))
+        onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
+    return {
+        comma,
+        found,
+        spaceBefore,
+        comment,
+        hasNewline,
+        anchor,
+        tag,
+        newlineAfterProp,
+        end,
+        start: start ?? end
+    };
+}
+
+export { resolveProps };

node_modules/yaml/browser/dist/compose/util-contains-newline.js

@@ -0,0 +1,34 @@
+function containsNewline(key) {
+    if (!key)
+        return null;
+    switch (key.type) {
+        case 'alias':
+        case 'scalar':
+        case 'double-quoted-scalar':
+        case 'single-quoted-scalar':
+            if (key.source.includes('\n'))
+                return true;
+            if (key.end)
+                for (const st of key.end)
+                    if (st.type === 'newline')
+                        return true;
+            return false;
+        case 'flow-collection':
+            for (const it of key.items) {
+                for (const st of it.start)
+                    if (st.type === 'newline')
+                        return true;
+                if (it.sep)
+                    for (const st of it.sep)
+                        if (st.type === 'newline')
+                            return true;
+                if (containsNewline(it.key) || containsNewline(it.value))
+                    return true;
+            }
+            return false;
+        default:
+            return true;
+    }
+}
+
+export { containsNewline };

node_modules/yaml/browser/dist/compose/util-empty-scalar-position.js

@@ -0,0 +1,26 @@
+function emptyScalarPosition(offset, before, pos) {
+    if (before) {
+        pos ?? (pos = before.length);
+        for (let i = pos - 1; i >= 0; --i) {
+            let st = before[i];
+            switch (st.type) {
+                case 'space':
+                case 'comment':
+                case 'newline':
+                    offset -= st.source.length;
+                    continue;
+            }
+            // Technically, an empty scalar is immediately after the last non-empty
+            // node, but it's more useful to place it after any whitespace.
+            st = before[++i];
+            while (st?.type === 'space') {
+                offset += st.source.length;
+                st = before[++i];
+            }
+            break;
+        }
+    }
+    return offset;
+}
+
+export { emptyScalarPosition };

node_modules/yaml/browser/dist/compose/util-flow-indent-check.js

@@ -0,0 +1,15 @@
+import { containsNewline } from './util-contains-newline.js';
+
+function flowIndentCheck(indent, fc, onError) {
+    if (fc?.type === 'flow-collection') {
+        const end = fc.end[0];
+        if (end.indent === indent &&
+            (end.source === ']' || end.source === '}') &&
+            containsNewline(fc)) {
+            const msg = 'Flow end indicator should be more indented than parent';
+            onError(end, 'BAD_INDENT', msg, true);
+        }
+    }
+}
+
+export { flowIndentCheck };

node_modules/yaml/browser/dist/compose/util-map-includes.js

@@ -0,0 +1,13 @@
+import { isScalar } from '../nodes/identity.js';
+
+function mapIncludes(ctx, items, search) {
+    const { uniqueKeys } = ctx.options;
+    if (uniqueKeys === false)
+        return false;
+    const isEqual = typeof uniqueKeys === 'function'
+        ? uniqueKeys
+        : (a, b) => a === b || (isScalar(a) && isScalar(b) && a.value === b.value);
+    return items.some(pair => isEqual(pair.key, search));
+}
+
+export { mapIncludes };

node_modules/yaml/browser/dist/doc/Document.js

@@ -0,0 +1,335 @@
+import { Alias } from '../nodes/Alias.js';
+import { isEmptyPath, collectionFromPath } from '../nodes/Collection.js';
+import { NODE_TYPE, DOC, isNode, isCollection, isScalar } from '../nodes/identity.js';
+import { Pair } from '../nodes/Pair.js';
+import { toJS } from '../nodes/toJS.js';
+import { Schema } from '../schema/Schema.js';
+import { stringifyDocument } from '../stringify/stringifyDocument.js';
+import { anchorNames, findNewAnchor, createNodeAnchors } from './anchors.js';
+import { applyReviver } from './applyReviver.js';
+import { createNode } from './createNode.js';
+import { Directives } from './directives.js';
+
+class Document {
+    constructor(value, replacer, options) {
+        /** A comment before this Document */
+        this.commentBefore = null;
+        /** A comment immediately after this Document */
+        this.comment = null;
+        /** Errors encountered during parsing. */
+        this.errors = [];
+        /** Warnings encountered during parsing. */
+        this.warnings = [];
+        Object.defineProperty(this, NODE_TYPE, { value: DOC });
+        let _replacer = null;
+        if (typeof replacer === 'function' || Array.isArray(replacer)) {
+            _replacer = replacer;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
+        }
+        const opt = Object.assign({
+            intAsBigInt: false,
+            keepSourceTokens: false,
+            logLevel: 'warn',
+            prettyErrors: true,
+            strict: true,
+            stringKeys: false,
+            uniqueKeys: true,
+            version: '1.2'
+        }, options);
+        this.options = opt;
+        let { version } = opt;
+        if (options?._directives) {
+            this.directives = options._directives.atDocument();
+            if (this.directives.yaml.explicit)
+                version = this.directives.yaml.version;
+        }
+        else
+            this.directives = new Directives({ version });
+        this.setSchema(version, options);
+        // @ts-expect-error We can't really know that this matches Contents.
+        this.contents =
+            value === undefined ? null : this.createNode(value, _replacer, options);
+    }
+    /**
+     * Create a deep copy of this Document and its contents.
+     *
+     * Custom Node values that inherit from `Object` still refer to their original instances.
+     */
+    clone() {
+        const copy = Object.create(Document.prototype, {
+            [NODE_TYPE]: { value: DOC }
+        });
+        copy.commentBefore = this.commentBefore;
+        copy.comment = this.comment;
+        copy.errors = this.errors.slice();
+        copy.warnings = this.warnings.slice();
+        copy.options = Object.assign({}, this.options);
+        if (this.directives)
+            copy.directives = this.directives.clone();
+        copy.schema = this.schema.clone();
+        // @ts-expect-error We can't really know that this matches Contents.
+        copy.contents = isNode(this.contents)
+            ? this.contents.clone(copy.schema)
+            : this.contents;
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /** Adds a value to the document. */
+    add(value) {
+        if (assertCollection(this.contents))
+            this.contents.add(value);
+    }
+    /** Adds a value to the document. */
+    addIn(path, value) {
+        if (assertCollection(this.contents))
+            this.contents.addIn(path, value);
+    }
+    /**
+     * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+     *
+     * If `node` already has an anchor, `name` is ignored.
+     * Otherwise, the `node.anchor` value will be set to `name`,
+     * or if an anchor with that name is already present in the document,
+     * `name` will be used as a prefix for a new unique anchor.
+     * If `name` is undefined, the generated anchor will use 'a' as a prefix.
+     */
+    createAlias(node, name) {
+        if (!node.anchor) {
+            const prev = anchorNames(this);
+            node.anchor =
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+                !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name;
+        }
+        return new Alias(node.anchor);
+    }
+    createNode(value, replacer, options) {
+        let _replacer = undefined;
+        if (typeof replacer === 'function') {
+            value = replacer.call({ '': value }, '', value);
+            _replacer = replacer;
+        }
+        else if (Array.isArray(replacer)) {
+            const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number;
+            const asStr = replacer.filter(keyToStr).map(String);
+            if (asStr.length > 0)
+                replacer = replacer.concat(asStr);
+            _replacer = replacer;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
+        }
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {};
+        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, 
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        anchorPrefix || 'a');
+        const ctx = {
+            aliasDuplicateObjects: aliasDuplicateObjects ?? true,
+            keepUndefined: keepUndefined ?? false,
+            onAnchor,
+            onTagObj,
+            replacer: _replacer,
+            schema: this.schema,
+            sourceObjects
+        };
+        const node = createNode(value, tag, ctx);
+        if (flow && isCollection(node))
+            node.flow = true;
+        setAnchors();
+        return node;
+    }
+    /**
+     * Convert a key and a value into a `Pair` using the current schema,
+     * recursively wrapping all values as `Scalar` or `Collection` nodes.
+     */
+    createPair(key, value, options = {}) {
+        const k = this.createNode(key, null, options);
+        const v = this.createNode(value, null, options);
+        return new Pair(k, v);
+    }
+    /**
+     * Removes a value from the document.
+     * @returns `true` if the item was found and removed.
+     */
+    delete(key) {
+        return assertCollection(this.contents) ? this.contents.delete(key) : false;
+    }
+    /**
+     * Removes a value from the document.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        if (isEmptyPath(path)) {
+            if (this.contents == null)
+                return false;
+            // @ts-expect-error Presumed impossible if Strict extends false
+            this.contents = null;
+            return true;
+        }
+        return assertCollection(this.contents)
+            ? this.contents.deleteIn(path)
+            : false;
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    get(key, keepScalar) {
+        return isCollection(this.contents)
+            ? this.contents.get(key, keepScalar)
+            : undefined;
+    }
+    /**
+     * Returns item at `path`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        if (isEmptyPath(path))
+            return !keepScalar && isScalar(this.contents)
+                ? this.contents.value
+                : this.contents;
+        return isCollection(this.contents)
+            ? this.contents.getIn(path, keepScalar)
+            : undefined;
+    }
+    /**
+     * Checks if the document includes a value with the key `key`.
+     */
+    has(key) {
+        return isCollection(this.contents) ? this.contents.has(key) : false;
+    }
+    /**
+     * Checks if the document includes a value at `path`.
+     */
+    hasIn(path) {
+        if (isEmptyPath(path))
+            return this.contents !== undefined;
+        return isCollection(this.contents) ? this.contents.hasIn(path) : false;
+    }
+    /**
+     * Sets a value in this document. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    set(key, value) {
+        if (this.contents == null) {
+            // @ts-expect-error We can't really know that this matches Contents.
+            this.contents = collectionFromPath(this.schema, [key], value);
+        }
+        else if (assertCollection(this.contents)) {
+            this.contents.set(key, value);
+        }
+    }
+    /**
+     * Sets a value in this document. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        if (isEmptyPath(path)) {
+            // @ts-expect-error We can't really know that this matches Contents.
+            this.contents = value;
+        }
+        else if (this.contents == null) {
+            // @ts-expect-error We can't really know that this matches Contents.
+            this.contents = collectionFromPath(this.schema, Array.from(path), value);
+        }
+        else if (assertCollection(this.contents)) {
+            this.contents.setIn(path, value);
+        }
+    }
+    /**
+     * Change the YAML version and schema used by the document.
+     * A `null` version disables support for directives, explicit tags, anchors, and aliases.
+     * It also requires the `schema` option to be given as a `Schema` instance value.
+     *
+     * Overrides all previously set schema options.
+     */
+    setSchema(version, options = {}) {
+        if (typeof version === 'number')
+            version = String(version);
+        let opt;
+        switch (version) {
+            case '1.1':
+                if (this.directives)
+                    this.directives.yaml.version = '1.1';
+                else
+                    this.directives = new Directives({ version: '1.1' });
+                opt = { resolveKnownTags: false, schema: 'yaml-1.1' };
+                break;
+            case '1.2':
+            case 'next':
+                if (this.directives)
+                    this.directives.yaml.version = version;
+                else
+                    this.directives = new Directives({ version });
+                opt = { resolveKnownTags: true, schema: 'core' };
+                break;
+            case null:
+                if (this.directives)
+                    delete this.directives;
+                opt = null;
+                break;
+            default: {
+                const sv = JSON.stringify(version);
+                throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
+            }
+        }
+        // Not using `instanceof Schema` to allow for duck typing
+        if (options.schema instanceof Object)
+            this.schema = options.schema;
+        else if (opt)
+            this.schema = new Schema(Object.assign(opt, options));
+        else
+            throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
+    }
+    // json & jsonArg are only used from toJSON()
+    toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        const ctx = {
+            anchors: new Map(),
+            doc: this,
+            keep: !json,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
+        };
+        const res = toJS(this.contents, jsonArg ?? '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+    /**
+     * A JSON representation of the document `contents`.
+     *
+     * @param jsonArg Used by `JSON.stringify` to indicate the array index or
+     *   property name.
+     */
+    toJSON(jsonArg, onAnchor) {
+        return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor });
+    }
+    /** A YAML representation of the document. */
+    toString(options = {}) {
+        if (this.errors.length > 0)
+            throw new Error('Document with errors cannot be stringified');
+        if ('indent' in options &&
+            (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
+            const s = JSON.stringify(options.indent);
+            throw new Error(`"indent" option must be a positive integer, not ${s}`);
+        }
+        return stringifyDocument(this, options);
+    }
+}
+function assertCollection(contents) {
+    if (isCollection(contents))
+        return true;
+    throw new Error('Expected a YAML collection as document contents');
+}
+
+export { Document };

node_modules/yaml/browser/dist/doc/anchors.js

@@ -0,0 +1,71 @@
+import { isScalar, isCollection } from '../nodes/identity.js';
+import { visit } from '../visit.js';
+
+/**
+ * Verify that the input string is a valid anchor.
+ *
+ * Will throw on errors.
+ */
+function anchorIsValid(anchor) {
+    if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
+        const sa = JSON.stringify(anchor);
+        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;
+        throw new Error(msg);
+    }
+    return true;
+}
+function anchorNames(root) {
+    const anchors = new Set();
+    visit(root, {
+        Value(_key, node) {
+            if (node.anchor)
+                anchors.add(node.anchor);
+        }
+    });
+    return anchors;
+}
+/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+function findNewAnchor(prefix, exclude) {
+    for (let i = 1; true; ++i) {
+        const name = `${prefix}${i}`;
+        if (!exclude.has(name))
+            return name;
+    }
+}
+function createNodeAnchors(doc, prefix) {
+    const aliasObjects = [];
+    const sourceObjects = new Map();
+    let prevAnchors = null;
+    return {
+        onAnchor: (source) => {
+            aliasObjects.push(source);
+            prevAnchors ?? (prevAnchors = anchorNames(doc));
+            const anchor = findNewAnchor(prefix, prevAnchors);
+            prevAnchors.add(anchor);
+            return anchor;
+        },
+        /**
+         * With circular references, the source node is only resolved after all
+         * of its child nodes are. This is why anchors are set only after all of
+         * the nodes have been created.
+         */
+        setAnchors: () => {
+            for (const source of aliasObjects) {
+                const ref = sourceObjects.get(source);
+                if (typeof ref === 'object' &&
+                    ref.anchor &&
+                    (isScalar(ref.node) || isCollection(ref.node))) {
+                    ref.node.anchor = ref.anchor;
+                }
+                else {
+                    const error = new Error('Failed to resolve repeated object (this should not happen)');
+                    error.source = source;
+                    throw error;
+                }
+            }
+        },
+        sourceObjects
+    };
+}
+
+export { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };

node_modules/yaml/browser/dist/doc/applyReviver.js

@@ -0,0 +1,55 @@
+/**
+ * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
+ * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
+ * 2021 edition: https://tc39.es/ecma262/#sec-json.parse
+ *
+ * Includes extensions for handling Map and Set objects.
+ */
+function applyReviver(reviver, obj, key, val) {
+    if (val && typeof val === 'object') {
+        if (Array.isArray(val)) {
+            for (let i = 0, len = val.length; i < len; ++i) {
+                const v0 = val[i];
+                const v1 = applyReviver(reviver, val, String(i), v0);
+                // eslint-disable-next-line @typescript-eslint/no-array-delete
+                if (v1 === undefined)
+                    delete val[i];
+                else if (v1 !== v0)
+                    val[i] = v1;
+            }
+        }
+        else if (val instanceof Map) {
+            for (const k of Array.from(val.keys())) {
+                const v0 = val.get(k);
+                const v1 = applyReviver(reviver, val, k, v0);
+                if (v1 === undefined)
+                    val.delete(k);
+                else if (v1 !== v0)
+                    val.set(k, v1);
+            }
+        }
+        else if (val instanceof Set) {
+            for (const v0 of Array.from(val)) {
+                const v1 = applyReviver(reviver, val, v0, v0);
+                if (v1 === undefined)
+                    val.delete(v0);
+                else if (v1 !== v0) {
+                    val.delete(v0);
+                    val.add(v1);
+                }
+            }
+        }
+        else {
+            for (const [k, v0] of Object.entries(val)) {
+                const v1 = applyReviver(reviver, val, k, v0);
+                if (v1 === undefined)
+                    delete val[k];
+                else if (v1 !== v0)
+                    val[k] = v1;
+            }
+        }
+    }
+    return reviver.call(obj, key, val);
+}
+
+export { applyReviver };

node_modules/yaml/browser/dist/doc/createNode.js

@@ -0,0 +1,88 @@
+import { Alias } from '../nodes/Alias.js';
+import { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+
+const defaultTagPrefix = 'tag:yaml.org,2002:';
+function findTagObject(value, tagName, tags) {
+    if (tagName) {
+        const match = tags.filter(t => t.tag === tagName);
+        const tagObj = match.find(t => !t.format) ?? match[0];
+        if (!tagObj)
+            throw new Error(`Tag ${tagName} not found`);
+        return tagObj;
+    }
+    return tags.find(t => t.identify?.(value) && !t.format);
+}
+function createNode(value, tagName, ctx) {
+    if (isDocument(value))
+        value = value.contents;
+    if (isNode(value))
+        return value;
+    if (isPair(value)) {
+        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);
+        map.items.push(value);
+        return map;
+    }
+    if (value instanceof String ||
+        value instanceof Number ||
+        value instanceof Boolean ||
+        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere
+    ) {
+        // https://tc39.es/ecma262/#sec-serializejsonproperty
+        value = value.valueOf();
+    }
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
+    // Detect duplicate references to the same object & use Alias nodes for all
+    // after first. The `ref` wrapper allows for circular references to resolve.
+    let ref = undefined;
+    if (aliasDuplicateObjects && value && typeof value === 'object') {
+        ref = sourceObjects.get(value);
+        if (ref) {
+            ref.anchor ?? (ref.anchor = onAnchor(value));
+            return new Alias(ref.anchor);
+        }
+        else {
+            ref = { anchor: null, node: null };
+            sourceObjects.set(value, ref);
+        }
+    }
+    if (tagName?.startsWith('!!'))
+        tagName = defaultTagPrefix + tagName.slice(2);
+    let tagObj = findTagObject(value, tagName, schema.tags);
+    if (!tagObj) {
+        if (value && typeof value.toJSON === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            value = value.toJSON();
+        }
+        if (!value || typeof value !== 'object') {
+            const node = new Scalar(value);
+            if (ref)
+                ref.node = node;
+            return node;
+        }
+        tagObj =
+            value instanceof Map
+                ? schema[MAP]
+                : Symbol.iterator in Object(value)
+                    ? schema[SEQ]
+                    : schema[MAP];
+    }
+    if (onTagObj) {
+        onTagObj(tagObj);
+        delete ctx.onTagObj;
+    }
+    const node = tagObj?.createNode
+        ? tagObj.createNode(ctx.schema, value, ctx)
+        : typeof tagObj?.nodeClass?.from === 'function'
+            ? tagObj.nodeClass.from(ctx.schema, value, ctx)
+            : new Scalar(value);
+    if (tagName)
+        node.tag = tagName;
+    else if (!tagObj.default)
+        node.tag = tagObj.tag;
+    if (ref)
+        ref.node = node;
+    return node;
+}
+
+export { createNode };

node_modules/yaml/browser/dist/doc/directives.js

@@ -0,0 +1,176 @@
+import { isNode } from '../nodes/identity.js';
+import { visit } from '../visit.js';
+
+const escapeChars = {
+    '!': '%21',
+    ',': '%2C',
+    '[': '%5B',
+    ']': '%5D',
+    '{': '%7B',
+    '}': '%7D'
+};
+const escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, ch => escapeChars[ch]);
+class Directives {
+    constructor(yaml, tags) {
+        /**
+         * The directives-end/doc-start marker `---`. If `null`, a marker may still be
+         * included in the document's stringified representation.
+         */
+        this.docStart = null;
+        /** The doc-end marker `...`.  */
+        this.docEnd = false;
+        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
+        this.tags = Object.assign({}, Directives.defaultTags, tags);
+    }
+    clone() {
+        const copy = new Directives(this.yaml, this.tags);
+        copy.docStart = this.docStart;
+        return copy;
+    }
+    /**
+     * During parsing, get a Directives instance for the current document and
+     * update the stream state according to the current version's spec.
+     */
+    atDocument() {
+        const res = new Directives(this.yaml, this.tags);
+        switch (this.yaml.version) {
+            case '1.1':
+                this.atNextDocument = true;
+                break;
+            case '1.2':
+                this.atNextDocument = false;
+                this.yaml = {
+                    explicit: Directives.defaultYaml.explicit,
+                    version: '1.2'
+                };
+                this.tags = Object.assign({}, Directives.defaultTags);
+                break;
+        }
+        return res;
+    }
+    /**
+     * @param onError - May be called even if the action was successful
+     * @returns `true` on success
+     */
+    add(line, onError) {
+        if (this.atNextDocument) {
+            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };
+            this.tags = Object.assign({}, Directives.defaultTags);
+            this.atNextDocument = false;
+        }
+        const parts = line.trim().split(/[ \t]+/);
+        const name = parts.shift();
+        switch (name) {
+            case '%TAG': {
+                if (parts.length !== 2) {
+                    onError(0, '%TAG directive should contain exactly two parts');
+                    if (parts.length < 2)
+                        return false;
+                }
+                const [handle, prefix] = parts;
+                this.tags[handle] = prefix;
+                return true;
+            }
+            case '%YAML': {
+                this.yaml.explicit = true;
+                if (parts.length !== 1) {
+                    onError(0, '%YAML directive should contain exactly one part');
+                    return false;
+                }
+                const [version] = parts;
+                if (version === '1.1' || version === '1.2') {
+                    this.yaml.version = version;
+                    return true;
+                }
+                else {
+                    const isValid = /^\d+\.\d+$/.test(version);
+                    onError(6, `Unsupported YAML version ${version}`, isValid);
+                    return false;
+                }
+            }
+            default:
+                onError(0, `Unknown directive ${name}`, true);
+                return false;
+        }
+    }
+    /**
+     * Resolves a tag, matching handles to those defined in %TAG directives.
+     *
+     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+     *   `'!local'` tag, or `null` if unresolvable.
+     */
+    tagName(source, onError) {
+        if (source === '!')
+            return '!'; // non-specific tag
+        if (source[0] !== '!') {
+            onError(`Not a valid tag: ${source}`);
+            return null;
+        }
+        if (source[1] === '<') {
+            const verbatim = source.slice(2, -1);
+            if (verbatim === '!' || verbatim === '!!') {
+                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
+                return null;
+            }
+            if (source[source.length - 1] !== '>')
+                onError('Verbatim tags must end with a >');
+            return verbatim;
+        }
+        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
+        if (!suffix)
+            onError(`The ${source} tag has no suffix`);
+        const prefix = this.tags[handle];
+        if (prefix) {
+            try {
+                return prefix + decodeURIComponent(suffix);
+            }
+            catch (error) {
+                onError(String(error));
+                return null;
+            }
+        }
+        if (handle === '!')
+            return source; // local tag
+        onError(`Could not resolve tag: ${source}`);
+        return null;
+    }
+    /**
+     * Given a fully resolved tag, returns its printable string form,
+     * taking into account current tag prefixes and defaults.
+     */
+    tagString(tag) {
+        for (const [handle, prefix] of Object.entries(this.tags)) {
+            if (tag.startsWith(prefix))
+                return handle + escapeTagName(tag.substring(prefix.length));
+        }
+        return tag[0] === '!' ? tag : `!<${tag}>`;
+    }
+    toString(doc) {
+        const lines = this.yaml.explicit
+            ? [`%YAML ${this.yaml.version || '1.2'}`]
+            : [];
+        const tagEntries = Object.entries(this.tags);
+        let tagNames;
+        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {
+            const tags = {};
+            visit(doc.contents, (_key, node) => {
+                if (isNode(node) && node.tag)
+                    tags[node.tag] = true;
+            });
+            tagNames = Object.keys(tags);
+        }
+        else
+            tagNames = [];
+        for (const [handle, prefix] of tagEntries) {
+            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')
+                continue;
+            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))
+                lines.push(`%TAG ${handle} ${prefix}`);
+        }
+        return lines.join('\n');
+    }
+}
+Directives.defaultYaml = { explicit: false, version: '1.2' };
+Directives.defaultTags = { '!!': 'tag:yaml.org,2002:' };
+
+export { Directives };

node_modules/yaml/browser/dist/errors.js

@@ -0,0 +1,57 @@
+class YAMLError extends Error {
+    constructor(name, pos, code, message) {
+        super();
+        this.name = name;
+        this.code = code;
+        this.message = message;
+        this.pos = pos;
+    }
+}
+class YAMLParseError extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLParseError', pos, code, message);
+    }
+}
+class YAMLWarning extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLWarning', pos, code, message);
+    }
+}
+const prettifyError = (src, lc) => (error) => {
+    if (error.pos[0] === -1)
+        return;
+    error.linePos = error.pos.map(pos => lc.linePos(pos));
+    const { line, col } = error.linePos[0];
+    error.message += ` at line ${line}, column ${col}`;
+    let ci = col - 1;
+    let lineStr = src
+        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])
+        .replace(/[\n\r]+$/, '');
+    // Trim to max 80 chars, keeping col position near the middle
+    if (ci >= 60 && lineStr.length > 80) {
+        const trimStart = Math.min(ci - 39, lineStr.length - 79);
+        lineStr = '…' + lineStr.substring(trimStart);
+        ci -= trimStart - 1;
+    }
+    if (lineStr.length > 80)
+        lineStr = lineStr.substring(0, 79) + '…';
+    // Include previous line in context if pointing at line start
+    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+        // Regexp won't match if start is trimmed
+        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+        if (prev.length > 80)
+            prev = prev.substring(0, 79) + '…\n';
+        lineStr = prev + lineStr;
+    }
+    if (/[^ ]/.test(lineStr)) {
+        let count = 1;
+        const end = error.linePos[1];
+        if (end?.line === line && end.col > col) {
+            count = Math.max(1, Math.min(end.col - col, 80 - ci));
+        }
+        const pointer = ' '.repeat(ci) + '^'.repeat(count);
+        error.message += `:\n\n${lineStr}\n${pointer}\n`;
+    }
+};
+
+export { YAMLError, YAMLParseError, YAMLWarning, prettifyError };

node_modules/yaml/browser/dist/index.js

@@ -0,0 +1,17 @@
+export { Composer } from './compose/composer.js';
+export { Document } from './doc/Document.js';
+export { Schema } from './schema/Schema.js';
+export { YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
+export { Alias } from './nodes/Alias.js';
+export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq } from './nodes/identity.js';
+export { Pair } from './nodes/Pair.js';
+export { Scalar } from './nodes/Scalar.js';
+export { YAMLMap } from './nodes/YAMLMap.js';
+export { YAMLSeq } from './nodes/YAMLSeq.js';
+import * as cst from './parse/cst.js';
+export { cst as CST };
+export { Lexer } from './parse/lexer.js';
+export { LineCounter } from './parse/line-counter.js';
+export { Parser } from './parse/parser.js';
+export { parse, parseAllDocuments, parseDocument, stringify } from './public-api.js';
+export { visit, visitAsync } from './visit.js';

node_modules/yaml/browser/dist/log.js

@@ -0,0 +1,11 @@
+function debug(logLevel, ...messages) {
+    if (logLevel === 'debug')
+        console.log(...messages);
+}
+function warn(logLevel, warning) {
+    if (logLevel === 'debug' || logLevel === 'warn') {
+        console.warn(warning);
+    }
+}
+
+export { debug, warn };

node_modules/yaml/browser/dist/nodes/Alias.js

@@ -0,0 +1,114 @@
+import { anchorIsValid } from '../doc/anchors.js';
+import { visit } from '../visit.js';
+import { ALIAS, isAlias, isCollection, isPair, hasAnchor } from './identity.js';
+import { NodeBase } from './Node.js';
+import { toJS } from './toJS.js';
+
+class Alias extends NodeBase {
+    constructor(source) {
+        super(ALIAS);
+        this.source = source;
+        Object.defineProperty(this, 'tag', {
+            set() {
+                throw new Error('Alias nodes cannot have tags');
+            }
+        });
+    }
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc, ctx) {
+        let nodes;
+        if (ctx?.aliasResolveCache) {
+            nodes = ctx.aliasResolveCache;
+        }
+        else {
+            nodes = [];
+            visit(doc, {
+                Node: (_key, node) => {
+                    if (isAlias(node) || hasAnchor(node))
+                        nodes.push(node);
+                }
+            });
+            if (ctx)
+                ctx.aliasResolveCache = nodes;
+        }
+        let found = undefined;
+        for (const node of nodes) {
+            if (node === this)
+                break;
+            if (node.anchor === this.source)
+                found = node;
+        }
+        return found;
+    }
+    toJSON(_arg, ctx) {
+        if (!ctx)
+            return { source: this.source };
+        const { anchors, doc, maxAliasCount } = ctx;
+        const source = this.resolve(doc, ctx);
+        if (!source) {
+            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+            throw new ReferenceError(msg);
+        }
+        let data = anchors.get(source);
+        if (!data) {
+            // Resolve anchors for Node.prototype.toJS()
+            toJS(source, null, ctx);
+            data = anchors.get(source);
+        }
+        /* istanbul ignore if */
+        if (data?.res === undefined) {
+            const msg = 'This should not happen: Alias anchor was not resolved?';
+            throw new ReferenceError(msg);
+        }
+        if (maxAliasCount >= 0) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+                data.aliasCount = getAliasCount(doc, source, anchors);
+            if (data.count * data.aliasCount > maxAliasCount) {
+                const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                throw new ReferenceError(msg);
+            }
+        }
+        return data.res;
+    }
+    toString(ctx, _onComment, _onChompKeep) {
+        const src = `*${this.source}`;
+        if (ctx) {
+            anchorIsValid(this.source);
+            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+                throw new Error(msg);
+            }
+            if (ctx.implicitKey)
+                return `${src} `;
+        }
+        return src;
+    }
+}
+function getAliasCount(doc, node, anchors) {
+    if (isAlias(node)) {
+        const source = node.resolve(doc);
+        const anchor = anchors && source && anchors.get(source);
+        return anchor ? anchor.count * anchor.aliasCount : 0;
+    }
+    else if (isCollection(node)) {
+        let count = 0;
+        for (const item of node.items) {
+            const c = getAliasCount(doc, item, anchors);
+            if (c > count)
+                count = c;
+        }
+        return count;
+    }
+    else if (isPair(node)) {
+        const kc = getAliasCount(doc, node.key, anchors);
+        const vc = getAliasCount(doc, node.value, anchors);
+        return Math.max(kc, vc);
+    }
+    return 1;
+}
+
+export { Alias };

node_modules/yaml/browser/dist/nodes/Collection.js

@@ -0,0 +1,147 @@
+import { createNode } from '../doc/createNode.js';
+import { isNode, isPair, isCollection, isScalar } from './identity.js';
+import { NodeBase } from './Node.js';
+
+function collectionFromPath(schema, path, value) {
+    let v = value;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const k = path[i];
+        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
+            const a = [];
+            a[k] = v;
+            v = a;
+        }
+        else {
+            v = new Map([[k, v]]);
+        }
+    }
+    return createNode(v, undefined, {
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
+        },
+        schema,
+        sourceObjects: new Map()
+    });
+}
+// Type guard is intentionally a little wrong so as to be more useful,
+// as it does not cover untypable empty non-string iterables (e.g. []).
+const isEmptyPath = (path) => path == null ||
+    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);
+class Collection extends NodeBase {
+    constructor(type, schema) {
+        super(type);
+        Object.defineProperty(this, 'schema', {
+            value: schema,
+            configurable: true,
+            enumerable: false,
+            writable: true
+        });
+    }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path, value) {
+        if (isEmptyPath(path))
+            this.add(value);
+        else {
+            const [key, ...rest] = path;
+            const node = this.get(key, true);
+            if (isCollection(node))
+                node.addIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.delete(key);
+        const node = this.get(key, true);
+        if (isCollection(node))
+            return node.deleteIn(rest);
+        else
+            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
+        const node = this.get(key, true);
+        if (rest.length === 0)
+            return !keepScalar && isScalar(node) ? node.value : node;
+        else
+            return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
+    }
+    hasAllNullValues(allowScalar) {
+        return this.items.every(node => {
+            if (!isPair(node))
+                return false;
+            const n = node.value;
+            return (n == null ||
+                (allowScalar &&
+                    isScalar(n) &&
+                    n.value == null &&
+                    !n.commentBefore &&
+                    !n.comment &&
+                    !n.tag));
+        });
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.has(key);
+        const node = this.get(key, true);
+        return isCollection(node) ? node.hasIn(rest) : false;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        const [key, ...rest] = path;
+        if (rest.length === 0) {
+            this.set(key, value);
+        }
+        else {
+            const node = this.get(key, true);
+            if (isCollection(node))
+                node.setIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+}
+
+export { Collection, collectionFromPath, isEmptyPath };

node_modules/yaml/browser/dist/nodes/Node.js

@@ -0,0 +1,38 @@
+import { applyReviver } from '../doc/applyReviver.js';
+import { NODE_TYPE, isDocument } from './identity.js';
+import { toJS } from './toJS.js';
+
+class NodeBase {
+    constructor(type) {
+        Object.defineProperty(this, NODE_TYPE, { value: type });
+    }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /** A plain JavaScript representation of this node. */
+    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        if (!isDocument(doc))
+            throw new TypeError('A document argument is required');
+        const ctx = {
+            anchors: new Map(),
+            doc,
+            keep: true,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
+        };
+        const res = toJS(this, '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+}
+
+export { NodeBase };

node_modules/yaml/browser/dist/nodes/Pair.js

@@ -0,0 +1,36 @@
+import { createNode } from '../doc/createNode.js';
+import { stringifyPair } from '../stringify/stringifyPair.js';
+import { addPairToJSMap } from './addPairToJSMap.js';
+import { NODE_TYPE, PAIR, isNode } from './identity.js';
+
+function createPair(key, value, ctx) {
+    const k = createNode(key, undefined, ctx);
+    const v = createNode(value, undefined, ctx);
+    return new Pair(k, v);
+}
+class Pair {
+    constructor(key, value = null) {
+        Object.defineProperty(this, NODE_TYPE, { value: PAIR });
+        this.key = key;
+        this.value = value;
+    }
+    clone(schema) {
+        let { key, value } = this;
+        if (isNode(key))
+            key = key.clone(schema);
+        if (isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
+    toJSON(_, ctx) {
+        const pair = ctx?.mapAsMap ? new Map() : {};
+        return addPairToJSMap(ctx, pair, this);
+    }
+    toString(ctx, onComment, onChompKeep) {
+        return ctx?.doc
+            ? stringifyPair(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
+    }
+}
+
+export { Pair, createPair };

node_modules/yaml/browser/dist/nodes/Scalar.js

@@ -0,0 +1,24 @@
+import { SCALAR } from './identity.js';
+import { NodeBase } from './Node.js';
+import { toJS } from './toJS.js';
+
+const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');
+class Scalar extends NodeBase {
+    constructor(value) {
+        super(SCALAR);
+        this.value = value;
+    }
+    toJSON(arg, ctx) {
+        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);
+    }
+    toString() {
+        return String(this.value);
+    }
+}
+Scalar.BLOCK_FOLDED = 'BLOCK_FOLDED';
+Scalar.BLOCK_LITERAL = 'BLOCK_LITERAL';
+Scalar.PLAIN = 'PLAIN';
+Scalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+Scalar.QUOTE_SINGLE = 'QUOTE_SINGLE';
+
+export { Scalar, isScalarValue };

node_modules/yaml/browser/dist/nodes/YAMLMap.js

@@ -0,0 +1,144 @@
+import { stringifyCollection } from '../stringify/stringifyCollection.js';
+import { addPairToJSMap } from './addPairToJSMap.js';
+import { Collection } from './Collection.js';
+import { MAP, isPair, isScalar } from './identity.js';
+import { Pair, createPair } from './Pair.js';
+import { isScalarValue } from './Scalar.js';
+
+function findPair(items, key) {
+    const k = isScalar(key) ? key.value : key;
+    for (const it of items) {
+        if (isPair(it)) {
+            if (it.key === key || it.key === k)
+                return it;
+            if (isScalar(it.key) && it.key.value === k)
+                return it;
+        }
+    }
+    return undefined;
+}
+class YAMLMap extends Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:map';
+    }
+    constructor(schema) {
+        super(MAP, schema);
+        this.items = [];
+    }
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema, obj, ctx) {
+        const { keepUndefined, replacer } = ctx;
+        const map = new this(schema);
+        const add = (key, value) => {
+            if (typeof replacer === 'function')
+                value = replacer.call(obj, key, value);
+            else if (Array.isArray(replacer) && !replacer.includes(key))
+                return;
+            if (value !== undefined || keepUndefined)
+                map.items.push(createPair(key, value, ctx));
+        };
+        if (obj instanceof Map) {
+            for (const [key, value] of obj)
+                add(key, value);
+        }
+        else if (obj && typeof obj === 'object') {
+            for (const key of Object.keys(obj))
+                add(key, obj[key]);
+        }
+        if (typeof schema.sortMapEntries === 'function') {
+            map.items.sort(schema.sortMapEntries);
+        }
+        return map;
+    }
+    /**
+     * Adds a value to the collection.
+     *
+     * @param overwrite - If not set `true`, using a key that is already in the
+     *   collection will throw. Otherwise, overwrites the previous value.
+     */
+    add(pair, overwrite) {
+        let _pair;
+        if (isPair(pair))
+            _pair = pair;
+        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
+            // In TypeScript, this never happens.
+            _pair = new Pair(pair, pair?.value);
+        }
+        else
+            _pair = new Pair(pair.key, pair.value);
+        const prev = findPair(this.items, _pair.key);
+        const sortEntries = this.schema?.sortMapEntries;
+        if (prev) {
+            if (!overwrite)
+                throw new Error(`Key ${_pair.key} already set`);
+            // For scalars, keep the old node & its comments and anchors
+            if (isScalar(prev.value) && isScalarValue(_pair.value))
+                prev.value.value = _pair.value;
+            else
+                prev.value = _pair.value;
+        }
+        else if (sortEntries) {
+            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);
+            if (i === -1)
+                this.items.push(_pair);
+            else
+                this.items.splice(i, 0, _pair);
+        }
+        else {
+            this.items.push(_pair);
+        }
+    }
+    delete(key) {
+        const it = findPair(this.items, key);
+        if (!it)
+            return false;
+        const del = this.items.splice(this.items.indexOf(it), 1);
+        return del.length > 0;
+    }
+    get(key, keepScalar) {
+        const it = findPair(this.items, key);
+        const node = it?.value;
+        return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;
+    }
+    has(key) {
+        return !!findPair(this.items, key);
+    }
+    set(key, value) {
+        this.add(new Pair(key, value), true);
+    }
+    /**
+     * @param ctx - Conversion context, originally set in Document#toJS()
+     * @param {Class} Type - If set, forces the returned collection type
+     * @returns Instance of Type, Map, or Object
+     */
+    toJSON(_, ctx, Type) {
+        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};
+        if (ctx?.onCreate)
+            ctx.onCreate(map);
+        for (const item of this.items)
+            addPairToJSMap(ctx, map, item);
+        return map;
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        for (const item of this.items) {
+            if (!isPair(item))
+                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+        }
+        if (!ctx.allNullValues && this.hasAllNullValues(false))
+            ctx = Object.assign({}, ctx, { allNullValues: true });
+        return stringifyCollection(this, ctx, {
+            blockItemPrefix: '',
+            flowChars: { start: '{', end: '}' },
+            itemIndent: ctx.indent || '',
+            onChompKeep,
+            onComment
+        });
+    }
+}
+
+export { YAMLMap, findPair };

node_modules/yaml/browser/dist/nodes/YAMLSeq.js

@@ -0,0 +1,113 @@
+import { createNode } from '../doc/createNode.js';
+import { stringifyCollection } from '../stringify/stringifyCollection.js';
+import { Collection } from './Collection.js';
+import { SEQ, isScalar } from './identity.js';
+import { isScalarValue } from './Scalar.js';
+import { toJS } from './toJS.js';
+
+class YAMLSeq extends Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:seq';
+    }
+    constructor(schema) {
+        super(SEQ, schema);
+        this.items = [];
+    }
+    add(value) {
+        this.items.push(value);
+    }
+    /**
+     * Removes a value from the collection.
+     *
+     * `key` must contain a representation of an integer for this to succeed.
+     * It may be wrapped in a `Scalar`.
+     *
+     * @returns `true` if the item was found and removed.
+     */
+    delete(key) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            return false;
+        const del = this.items.splice(idx, 1);
+        return del.length > 0;
+    }
+    get(key, keepScalar) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            return undefined;
+        const it = this.items[idx];
+        return !keepScalar && isScalar(it) ? it.value : it;
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     *
+     * `key` must contain a representation of an integer for this to succeed.
+     * It may be wrapped in a `Scalar`.
+     */
+    has(key) {
+        const idx = asItemIndex(key);
+        return typeof idx === 'number' && idx < this.items.length;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     *
+     * If `key` does not contain a representation of an integer, this will throw.
+     * It may be wrapped in a `Scalar`.
+     */
+    set(key, value) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            throw new Error(`Expected a valid index, not ${key}.`);
+        const prev = this.items[idx];
+        if (isScalar(prev) && isScalarValue(value))
+            prev.value = value;
+        else
+            this.items[idx] = value;
+    }
+    toJSON(_, ctx) {
+        const seq = [];
+        if (ctx?.onCreate)
+            ctx.onCreate(seq);
+        let i = 0;
+        for (const item of this.items)
+            seq.push(toJS(item, String(i++), ctx));
+        return seq;
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        return stringifyCollection(this, ctx, {
+            blockItemPrefix: '- ',
+            flowChars: { start: '[', end: ']' },
+            itemIndent: (ctx.indent || '') + '  ',
+            onChompKeep,
+            onComment
+        });
+    }
+    static from(schema, obj, ctx) {
+        const { replacer } = ctx;
+        const seq = new this(schema);
+        if (obj && Symbol.iterator in Object(obj)) {
+            let i = 0;
+            for (let it of obj) {
+                if (typeof replacer === 'function') {
+                    const key = obj instanceof Set ? it : String(i++);
+                    it = replacer.call(obj, key, it);
+                }
+                seq.items.push(createNode(it, undefined, ctx));
+            }
+        }
+        return seq;
+    }
+}
+function asItemIndex(key) {
+    let idx = isScalar(key) ? key.value : key;
+    if (idx && typeof idx === 'string')
+        idx = Number(idx);
+    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0
+        ? idx
+        : null;
+}
+
+export { YAMLSeq };

node_modules/yaml/browser/dist/nodes/addPairToJSMap.js

@@ -0,0 +1,63 @@
+import { warn } from '../log.js';
+import { isMergeKey, addMergeToJSMap } from '../schema/yaml-1.1/merge.js';
+import { createStringifyContext } from '../stringify/stringify.js';
+import { isNode } from './identity.js';
+import { toJS } from './toJS.js';
+
+function addPairToJSMap(ctx, map, { key, value }) {
+    if (isNode(key) && key.addToJSMap)
+        key.addToJSMap(ctx, map, value);
+    // TODO: Should drop this special case for bare << handling
+    else if (isMergeKey(ctx, key))
+        addMergeToJSMap(ctx, map, value);
+    else {
+        const jsKey = toJS(key, '', ctx);
+        if (map instanceof Map) {
+            map.set(jsKey, toJS(value, jsKey, ctx));
+        }
+        else if (map instanceof Set) {
+            map.add(jsKey);
+        }
+        else {
+            const stringKey = stringifyKey(key, jsKey, ctx);
+            const jsValue = toJS(value, stringKey, ctx);
+            if (stringKey in map)
+                Object.defineProperty(map, stringKey, {
+                    value: jsValue,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            else
+                map[stringKey] = jsValue;
+        }
+    }
+    return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+    if (jsKey === null)
+        return '';
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    if (typeof jsKey !== 'object')
+        return String(jsKey);
+    if (isNode(key) && ctx?.doc) {
+        const strCtx = createStringifyContext(ctx.doc, {});
+        strCtx.anchors = new Set();
+        for (const node of ctx.anchors.keys())
+            strCtx.anchors.add(node.anchor);
+        strCtx.inFlow = true;
+        strCtx.inStringifyKey = true;
+        const strKey = key.toString(strCtx);
+        if (!ctx.mapKeyWarned) {
+            let jsonStr = JSON.stringify(strKey);
+            if (jsonStr.length > 40)
+                jsonStr = jsonStr.substring(0, 36) + '..."';
+            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+            ctx.mapKeyWarned = true;
+        }
+        return strKey;
+    }
+    return JSON.stringify(jsKey);
+}
+
+export { addPairToJSMap };

node_modules/yaml/browser/dist/nodes/identity.js

@@ -0,0 +1,36 @@
+const ALIAS = Symbol.for('yaml.alias');
+const DOC = Symbol.for('yaml.document');
+const MAP = Symbol.for('yaml.map');
+const PAIR = Symbol.for('yaml.pair');
+const SCALAR = Symbol.for('yaml.scalar');
+const SEQ = Symbol.for('yaml.seq');
+const NODE_TYPE = Symbol.for('yaml.node.type');
+const isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;
+const isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;
+const isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;
+const isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;
+const isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;
+const isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;
+function isCollection(node) {
+    if (node && typeof node === 'object')
+        switch (node[NODE_TYPE]) {
+            case MAP:
+            case SEQ:
+                return true;
+        }
+    return false;
+}
+function isNode(node) {
+    if (node && typeof node === 'object')
+        switch (node[NODE_TYPE]) {
+            case ALIAS:
+            case MAP:
+            case SCALAR:
+            case SEQ:
+                return true;
+        }
+    return false;
+}
+const hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
+
+export { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };

node_modules/yaml/browser/dist/nodes/toJS.js

@@ -0,0 +1,37 @@
+import { hasAnchor } from './identity.js';
+
+/**
+ * Recursively convert any node or its contents to native JavaScript
+ *
+ * @param value - The input value
+ * @param arg - If `value` defines a `toJSON()` method, use this
+ *   as its first argument
+ * @param ctx - Conversion context, originally set in Document#toJS(). If
+ *   `{ keep: true }` is not set, output should be suitable for JSON
+ *   stringification.
+ */
+function toJS(value, arg, ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    if (Array.isArray(value))
+        return value.map((v, i) => toJS(v, String(i), ctx));
+    if (value && typeof value.toJSON === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        if (!ctx || !hasAnchor(value))
+            return value.toJSON(arg, ctx);
+        const data = { aliasCount: 0, count: 1, res: undefined };
+        ctx.anchors.set(value, data);
+        ctx.onCreate = res => {
+            data.res = res;
+            delete ctx.onCreate;
+        };
+        const res = value.toJSON(arg, ctx);
+        if (ctx.onCreate)
+            ctx.onCreate(res);
+        return res;
+    }
+    if (typeof value === 'bigint' && !ctx?.keep)
+        return Number(value);
+    return value;
+}
+
+export { toJS };

node_modules/yaml/browser/dist/parse/cst-scalar.js

@@ -0,0 +1,214 @@
+import { resolveBlockScalar } from '../compose/resolve-block-scalar.js';
+import { resolveFlowScalar } from '../compose/resolve-flow-scalar.js';
+import { YAMLParseError } from '../errors.js';
+import { stringifyString } from '../stringify/stringifyString.js';
+
+function resolveAsScalar(token, strict = true, onError) {
+    if (token) {
+        const _onError = (pos, code, message) => {
+            const offset = typeof pos === 'number' ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
+            if (onError)
+                onError(offset, code, message);
+            else
+                throw new YAMLParseError([offset, offset + 1], code, message);
+        };
+        switch (token.type) {
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return resolveFlowScalar(token, strict, _onError);
+            case 'block-scalar':
+                return resolveBlockScalar({ options: { strict } }, token, _onError);
+        }
+    }
+    return null;
+}
+/**
+ * Create a new scalar token with `value`
+ *
+ * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+ * as this function does not support any schema operations and won't check for such conflicts.
+ *
+ * @param value The string representation of the value, which will have its content properly indented.
+ * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
+ * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+ * @param context.indent The indent level of the token.
+ * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
+ * @param context.offset The offset position of the token.
+ * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+ */
+function createScalarToken(value, context) {
+    const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context;
+    const source = stringifyString({ type, value }, {
+        implicitKey,
+        indent: indent > 0 ? ' '.repeat(indent) : '',
+        inFlow,
+        options: { blockQuote: true, lineWidth: -1 }
+    });
+    const end = context.end ?? [
+        { type: 'newline', offset: -1, indent, source: '\n' }
+    ];
+    switch (source[0]) {
+        case '|':
+        case '>': {
+            const he = source.indexOf('\n');
+            const head = source.substring(0, he);
+            const body = source.substring(he + 1) + '\n';
+            const props = [
+                { type: 'block-scalar-header', offset, indent, source: head }
+            ];
+            if (!addEndtoBlockProps(props, end))
+                props.push({ type: 'newline', offset: -1, indent, source: '\n' });
+            return { type: 'block-scalar', offset, indent, props, source: body };
+        }
+        case '"':
+            return { type: 'double-quoted-scalar', offset, indent, source, end };
+        case "'":
+            return { type: 'single-quoted-scalar', offset, indent, source, end };
+        default:
+            return { type: 'scalar', offset, indent, source, end };
+    }
+}
+/**
+ * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
+ *
+ * Best efforts are made to retain any comments previously associated with the `token`,
+ * though all contents within a collection's `items` will be overwritten.
+ *
+ * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+ * as this function does not support any schema operations and won't check for such conflicts.
+ *
+ * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
+ * @param value The string representation of the value, which will have its content properly indented.
+ * @param context.afterKey In most cases, values after a key should have an additional level of indentation.
+ * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+ * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
+ * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+ */
+function setScalarValue(token, value, context = {}) {
+    let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+    let indent = 'indent' in token ? token.indent : null;
+    if (afterKey && typeof indent === 'number')
+        indent += 2;
+    if (!type)
+        switch (token.type) {
+            case 'single-quoted-scalar':
+                type = 'QUOTE_SINGLE';
+                break;
+            case 'double-quoted-scalar':
+                type = 'QUOTE_DOUBLE';
+                break;
+            case 'block-scalar': {
+                const header = token.props[0];
+                if (header.type !== 'block-scalar-header')
+                    throw new Error('Invalid block scalar header');
+                type = header.source[0] === '>' ? 'BLOCK_FOLDED' : 'BLOCK_LITERAL';
+                break;
+            }
+            default:
+                type = 'PLAIN';
+        }
+    const source = stringifyString({ type, value }, {
+        implicitKey: implicitKey || indent === null,
+        indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
+        inFlow,
+        options: { blockQuote: true, lineWidth: -1 }
+    });
+    switch (source[0]) {
+        case '|':
+        case '>':
+            setBlockScalarValue(token, source);
+            break;
+        case '"':
+            setFlowScalarValue(token, source, 'double-quoted-scalar');
+            break;
+        case "'":
+            setFlowScalarValue(token, source, 'single-quoted-scalar');
+            break;
+        default:
+            setFlowScalarValue(token, source, 'scalar');
+    }
+}
+function setBlockScalarValue(token, source) {
+    const he = source.indexOf('\n');
+    const head = source.substring(0, he);
+    const body = source.substring(he + 1) + '\n';
+    if (token.type === 'block-scalar') {
+        const header = token.props[0];
+        if (header.type !== 'block-scalar-header')
+            throw new Error('Invalid block scalar header');
+        header.source = head;
+        token.source = body;
+    }
+    else {
+        const { offset } = token;
+        const indent = 'indent' in token ? token.indent : -1;
+        const props = [
+            { type: 'block-scalar-header', offset, indent, source: head }
+        ];
+        if (!addEndtoBlockProps(props, 'end' in token ? token.end : undefined))
+            props.push({ type: 'newline', offset: -1, indent, source: '\n' });
+        for (const key of Object.keys(token))
+            if (key !== 'type' && key !== 'offset')
+                delete token[key];
+        Object.assign(token, { type: 'block-scalar', indent, props, source: body });
+    }
+}
+/** @returns `true` if last token is a newline */
+function addEndtoBlockProps(props, end) {
+    if (end)
+        for (const st of end)
+            switch (st.type) {
+                case 'space':
+                case 'comment':
+                    props.push(st);
+                    break;
+                case 'newline':
+                    props.push(st);
+                    return true;
+            }
+    return false;
+}
+function setFlowScalarValue(token, source, type) {
+    switch (token.type) {
+        case 'scalar':
+        case 'double-quoted-scalar':
+        case 'single-quoted-scalar':
+            token.type = type;
+            token.source = source;
+            break;
+        case 'block-scalar': {
+            const end = token.props.slice(1);
+            let oa = source.length;
+            if (token.props[0].type === 'block-scalar-header')
+                oa -= token.props[0].source.length;
+            for (const tok of end)
+                tok.offset += oa;
+            delete token.props;
+            Object.assign(token, { type, source, end });
+            break;
+        }
+        case 'block-map':
+        case 'block-seq': {
+            const offset = token.offset + source.length;
+            const nl = { type: 'newline', offset, indent: token.indent, source: '\n' };
+            delete token.items;
+            Object.assign(token, { type, source, end: [nl] });
+            break;
+        }
+        default: {
+            const indent = 'indent' in token ? token.indent : -1;
+            const end = 'end' in token && Array.isArray(token.end)
+                ? token.end.filter(st => st.type === 'space' ||
+                    st.type === 'comment' ||
+                    st.type === 'newline')
+                : [];
+            for (const key of Object.keys(token))
+                if (key !== 'type' && key !== 'offset')
+                    delete token[key];
+            Object.assign(token, { type, indent, source, end });
+        }
+    }
+}
+
+export { createScalarToken, resolveAsScalar, setScalarValue };

node_modules/yaml/browser/dist/parse/cst-stringify.js

@@ -0,0 +1,61 @@
+/**
+ * Stringify a CST document, token, or collection item
+ *
+ * Fair warning: This applies no validation whatsoever, and
+ * simply concatenates the sources in their logical order.
+ */
+const stringify = (cst) => 'type' in cst ? stringifyToken(cst) : stringifyItem(cst);
+function stringifyToken(token) {
+    switch (token.type) {
+        case 'block-scalar': {
+            let res = '';
+            for (const tok of token.props)
+                res += stringifyToken(tok);
+            return res + token.source;
+        }
+        case 'block-map':
+        case 'block-seq': {
+            let res = '';
+            for (const item of token.items)
+                res += stringifyItem(item);
+            return res;
+        }
+        case 'flow-collection': {
+            let res = token.start.source;
+            for (const item of token.items)
+                res += stringifyItem(item);
+            for (const st of token.end)
+                res += st.source;
+            return res;
+        }
+        case 'document': {
+            let res = stringifyItem(token);
+            if (token.end)
+                for (const st of token.end)
+                    res += st.source;
+            return res;
+        }
+        default: {
+            let res = token.source;
+            if ('end' in token && token.end)
+                for (const st of token.end)
+                    res += st.source;
+            return res;
+        }
+    }
+}
+function stringifyItem({ start, key, sep, value }) {
+    let res = '';
+    for (const st of start)
+        res += st.source;
+    if (key)
+        res += stringifyToken(key);
+    if (sep)
+        for (const st of sep)
+            res += st.source;
+    if (value)
+        res += stringifyToken(value);
+    return res;
+}
+
+export { stringify };

node_modules/yaml/browser/dist/parse/cst-visit.js

@@ -0,0 +1,97 @@
+const BREAK = Symbol('break visit');
+const SKIP = Symbol('skip children');
+const REMOVE = Symbol('remove item');
+/**
+ * Apply a visitor to a CST document or item.
+ *
+ * Walks through the tree (depth-first) starting from the root, calling a
+ * `visitor` function with two arguments when entering each item:
+ *   - `item`: The current item, which included the following members:
+ *     - `start: SourceToken[]` – Source tokens before the key or value,
+ *       possibly including its anchor or tag.
+ *     - `key?: Token | null` – Set for pair values. May then be `null`, if
+ *       the key before the `:` separator is empty.
+ *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+ *       which should include the `:` map value indicator if `value` is set.
+ *     - `value?: Token` – The value of a sequence item, or of a map pair.
+ *   - `path`: The steps from the root to the current node, as an array of
+ *     `['key' | 'value', number]` tuples.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this token, continue with
+ *      next sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current item, then continue with the next one
+ *   - `number`: Set the index of the next step. This is useful especially if
+ *     the index of the current token has changed.
+ *   - `function`: Define the next visitor for this item. After the original
+ *     visitor is called on item entry, next visitors are called after handling
+ *     a non-empty `key` and when exiting the item.
+ */
+function visit(cst, visitor) {
+    if ('type' in cst && cst.type === 'document')
+        cst = { start: cst.start, value: cst.value };
+    _visit(Object.freeze([]), cst, visitor);
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visit.BREAK = BREAK;
+/** Do not visit the children of the current item */
+visit.SKIP = SKIP;
+/** Remove the current item */
+visit.REMOVE = REMOVE;
+/** Find the item at `path` from `cst` as the root */
+visit.itemAtPath = (cst, path) => {
+    let item = cst;
+    for (const [field, index] of path) {
+        const tok = item?.[field];
+        if (tok && 'items' in tok) {
+            item = tok.items[index];
+        }
+        else
+            return undefined;
+    }
+    return item;
+};
+/**
+ * Get the immediate parent collection of the item at `path` from `cst` as the root.
+ *
+ * Throws an error if the collection is not found, which should never happen if the item itself exists.
+ */
+visit.parentCollection = (cst, path) => {
+    const parent = visit.itemAtPath(cst, path.slice(0, -1));
+    const field = path[path.length - 1][0];
+    const coll = parent?.[field];
+    if (coll && 'items' in coll)
+        return coll;
+    throw new Error('Parent collection not found');
+};
+function _visit(path, item, visitor) {
+    let ctrl = visitor(item, path);
+    if (typeof ctrl === 'symbol')
+        return ctrl;
+    for (const field of ['key', 'value']) {
+        const token = item[field];
+        if (token && 'items' in token) {
+            for (let i = 0; i < token.items.length; ++i) {
+                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    token.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+            if (typeof ctrl === 'function' && field === 'key')
+                ctrl = ctrl(item, path);
+        }
+    }
+    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
+}
+
+export { visit };

node_modules/yaml/browser/dist/parse/cst.js

@@ -0,0 +1,98 @@
+export { createScalarToken, resolveAsScalar, setScalarValue } from './cst-scalar.js';
+export { stringify } from './cst-stringify.js';
+export { visit } from './cst-visit.js';
+
+/** The byte order mark */
+const BOM = '\u{FEFF}';
+/** Start of doc-mode */
+const DOCUMENT = '\x02'; // C0: Start of Text
+/** Unexpected end of flow-mode */
+const FLOW_END = '\x18'; // C0: Cancel
+/** Next token is a scalar value */
+const SCALAR = '\x1f'; // C0: Unit Separator
+/** @returns `true` if `token` is a flow or block collection */
+const isCollection = (token) => !!token && 'items' in token;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+const isScalar = (token) => !!token &&
+    (token.type === 'scalar' ||
+        token.type === 'single-quoted-scalar' ||
+        token.type === 'double-quoted-scalar' ||
+        token.type === 'block-scalar');
+/* istanbul ignore next */
+/** Get a printable representation of a lexer token */
+function prettyToken(token) {
+    switch (token) {
+        case BOM:
+            return '<BOM>';
+        case DOCUMENT:
+            return '<DOC>';
+        case FLOW_END:
+            return '<FLOW_END>';
+        case SCALAR:
+            return '<SCALAR>';
+        default:
+            return JSON.stringify(token);
+    }
+}
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+function tokenType(source) {
+    switch (source) {
+        case BOM:
+            return 'byte-order-mark';
+        case DOCUMENT:
+            return 'doc-mode';
+        case FLOW_END:
+            return 'flow-error-end';
+        case SCALAR:
+            return 'scalar';
+        case '---':
+            return 'doc-start';
+        case '...':
+            return 'doc-end';
+        case '':
+        case '\n':
+        case '\r\n':
+            return 'newline';
+        case '-':
+            return 'seq-item-ind';
+        case '?':
+            return 'explicit-key-ind';
+        case ':':
+            return 'map-value-ind';
+        case '{':
+            return 'flow-map-start';
+        case '}':
+            return 'flow-map-end';
+        case '[':
+            return 'flow-seq-start';
+        case ']':
+            return 'flow-seq-end';
+        case ',':
+            return 'comma';
+    }
+    switch (source[0]) {
+        case ' ':
+        case '\t':
+            return 'space';
+        case '#':
+            return 'comment';
+        case '%':
+            return 'directive-line';
+        case '*':
+            return 'alias';
+        case '&':
+            return 'anchor';
+        case '!':
+            return 'tag';
+        case "'":
+            return 'single-quoted-scalar';
+        case '"':
+            return 'double-quoted-scalar';
+        case '|':
+        case '>':
+            return 'block-scalar-header';
+    }
+    return null;
+}
+
+export { BOM, DOCUMENT, FLOW_END, SCALAR, isCollection, isScalar, prettyToken, tokenType };

node_modules/yaml/browser/dist/parse/lexer.js

@@ -0,0 +1,717 @@
+import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.js';
+
+/*
+START -> stream
+
+stream
+  directive -> line-end -> stream
+  indent + line-end -> stream
+  [else] -> line-start
+
+line-end
+  comment -> line-end
+  newline -> .
+  input-end -> END
+
+line-start
+  doc-start -> doc
+  doc-end -> stream
+  [else] -> indent -> block-start
+
+block-start
+  seq-item-start -> block-start
+  explicit-key-start -> block-start
+  map-value-start -> block-start
+  [else] -> doc
+
+doc
+  line-end -> line-start
+  spaces -> doc
+  anchor -> doc
+  tag -> doc
+  flow-start -> flow -> doc
+  flow-end -> error -> doc
+  seq-item-start -> error -> doc
+  explicit-key-start -> error -> doc
+  map-value-start -> doc
+  alias -> doc
+  quote-start -> quoted-scalar -> doc
+  block-scalar-header -> line-end -> block-scalar(min) -> line-start
+  [else] -> plain-scalar(false, min) -> doc
+
+flow
+  line-end -> flow
+  spaces -> flow
+  anchor -> flow
+  tag -> flow
+  flow-start -> flow -> flow
+  flow-end -> .
+  seq-item-start -> error -> flow
+  explicit-key-start -> flow
+  map-value-start -> flow
+  alias -> flow
+  quote-start -> quoted-scalar -> flow
+  comma -> flow
+  [else] -> plain-scalar(true, 0) -> flow
+
+quoted-scalar
+  quote-end -> .
+  [else] -> quoted-scalar
+
+block-scalar(min)
+  newline + peek(indent < min) -> .
+  [else] -> block-scalar(min)
+
+plain-scalar(is-flow, min)
+  scalar-end(is-flow) -> .
+  peek(newline + (indent < min)) -> .
+  [else] -> plain-scalar(min)
+*/
+function isEmpty(ch) {
+    switch (ch) {
+        case undefined:
+        case ' ':
+        case '\n':
+        case '\r':
+        case '\t':
+            return true;
+        default:
+            return false;
+    }
+}
+const hexDigits = new Set('0123456789ABCDEFabcdef');
+const tagChars = new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()");
+const flowIndicatorChars = new Set(',[]{}');
+const invalidAnchorChars = new Set(' ,[]{}\n\r\t');
+const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);
+/**
+ * Splits an input string into lexical tokens, i.e. smaller strings that are
+ * easily identifiable by `tokens.tokenType()`.
+ *
+ * Lexing starts always in a "stream" context. Incomplete input may be buffered
+ * until a complete token can be emitted.
+ *
+ * In addition to slices of the original input, the following control characters
+ * may also be emitted:
+ *
+ * - `\x02` (Start of Text): A document starts with the next token
+ * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
+ * - `\x1f` (Unit Separator): Next token is a scalar value
+ * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
+ */
+class Lexer {
+    constructor() {
+        /**
+         * Flag indicating whether the end of the current buffer marks the end of
+         * all input
+         */
+        this.atEnd = false;
+        /**
+         * Explicit indent set in block scalar header, as an offset from the current
+         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not
+         * explicitly set.
+         */
+        this.blockScalarIndent = -1;
+        /**
+         * Block scalars that include a + (keep) chomping indicator in their header
+         * include trailing empty lines, which are otherwise excluded from the
+         * scalar's contents.
+         */
+        this.blockScalarKeep = false;
+        /** Current input */
+        this.buffer = '';
+        /**
+         * Flag noting whether the map value indicator : can immediately follow this
+         * node within a flow context.
+         */
+        this.flowKey = false;
+        /** Count of surrounding flow collection levels. */
+        this.flowLevel = 0;
+        /**
+         * Minimum level of indentation required for next lines to be parsed as a
+         * part of the current scalar value.
+         */
+        this.indentNext = 0;
+        /** Indentation level of the current line. */
+        this.indentValue = 0;
+        /** Position of the next \n character. */
+        this.lineEndPos = null;
+        /** Stores the state of the lexer if reaching the end of incpomplete input */
+        this.next = null;
+        /** A pointer to `buffer`; the current position of the lexer. */
+        this.pos = 0;
+    }
+    /**
+     * Generate YAML tokens from the `source` string. If `incomplete`,
+     * a part of the last line may be left as a buffer for the next call.
+     *
+     * @returns A generator of lexical tokens
+     */
+    *lex(source, incomplete = false) {
+        if (source) {
+            if (typeof source !== 'string')
+                throw TypeError('source is not a string');
+            this.buffer = this.buffer ? this.buffer + source : source;
+            this.lineEndPos = null;
+        }
+        this.atEnd = !incomplete;
+        let next = this.next ?? 'stream';
+        while (next && (incomplete || this.hasChars(1)))
+            next = yield* this.parseNext(next);
+    }
+    atLineEnd() {
+        let i = this.pos;
+        let ch = this.buffer[i];
+        while (ch === ' ' || ch === '\t')
+            ch = this.buffer[++i];
+        if (!ch || ch === '#' || ch === '\n')
+            return true;
+        if (ch === '\r')
+            return this.buffer[i + 1] === '\n';
+        return false;
+    }
+    charAt(n) {
+        return this.buffer[this.pos + n];
+    }
+    continueScalar(offset) {
+        let ch = this.buffer[offset];
+        if (this.indentNext > 0) {
+            let indent = 0;
+            while (ch === ' ')
+                ch = this.buffer[++indent + offset];
+            if (ch === '\r') {
+                const next = this.buffer[indent + offset + 1];
+                if (next === '\n' || (!next && !this.atEnd))
+                    return offset + indent + 1;
+            }
+            return ch === '\n' || indent >= this.indentNext || (!ch && !this.atEnd)
+                ? offset + indent
+                : -1;
+        }
+        if (ch === '-' || ch === '.') {
+            const dt = this.buffer.substr(offset, 3);
+            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))
+                return -1;
+        }
+        return offset;
+    }
+    getLine() {
+        let end = this.lineEndPos;
+        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
+            end = this.buffer.indexOf('\n', this.pos);
+            this.lineEndPos = end;
+        }
+        if (end === -1)
+            return this.atEnd ? this.buffer.substring(this.pos) : null;
+        if (this.buffer[end - 1] === '\r')
+            end -= 1;
+        return this.buffer.substring(this.pos, end);
+    }
+    hasChars(n) {
+        return this.pos + n <= this.buffer.length;
+    }
+    setNext(state) {
+        this.buffer = this.buffer.substring(this.pos);
+        this.pos = 0;
+        this.lineEndPos = null;
+        this.next = state;
+        return null;
+    }
+    peek(n) {
+        return this.buffer.substr(this.pos, n);
+    }
+    *parseNext(next) {
+        switch (next) {
+            case 'stream':
+                return yield* this.parseStream();
+            case 'line-start':
+                return yield* this.parseLineStart();
+            case 'block-start':
+                return yield* this.parseBlockStart();
+            case 'doc':
+                return yield* this.parseDocument();
+            case 'flow':
+                return yield* this.parseFlowCollection();
+            case 'quoted-scalar':
+                return yield* this.parseQuotedScalar();
+            case 'block-scalar':
+                return yield* this.parseBlockScalar();
+            case 'plain-scalar':
+                return yield* this.parsePlainScalar();
+        }
+    }
+    *parseStream() {
+        let line = this.getLine();
+        if (line === null)
+            return this.setNext('stream');
+        if (line[0] === BOM) {
+            yield* this.pushCount(1);
+            line = line.substring(1);
+        }
+        if (line[0] === '%') {
+            let dirEnd = line.length;
+            let cs = line.indexOf('#');
+            while (cs !== -1) {
+                const ch = line[cs - 1];
+                if (ch === ' ' || ch === '\t') {
+                    dirEnd = cs - 1;
+                    break;
+                }
+                else {
+                    cs = line.indexOf('#', cs + 1);
+                }
+            }
+            while (true) {
+                const ch = line[dirEnd - 1];
+                if (ch === ' ' || ch === '\t')
+                    dirEnd -= 1;
+                else
+                    break;
+            }
+            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));
+            yield* this.pushCount(line.length - n); // possible comment
+            this.pushNewline();
+            return 'stream';
+        }
+        if (this.atLineEnd()) {
+            const sp = yield* this.pushSpaces(true);
+            yield* this.pushCount(line.length - sp);
+            yield* this.pushNewline();
+            return 'stream';
+        }
+        yield DOCUMENT;
+        return yield* this.parseLineStart();
+    }
+    *parseLineStart() {
+        const ch = this.charAt(0);
+        if (!ch && !this.atEnd)
+            return this.setNext('line-start');
+        if (ch === '-' || ch === '.') {
+            if (!this.atEnd && !this.hasChars(4))
+                return this.setNext('line-start');
+            const s = this.peek(3);
+            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {
+                yield* this.pushCount(3);
+                this.indentValue = 0;
+                this.indentNext = 0;
+                return s === '---' ? 'doc' : 'stream';
+            }
+        }
+        this.indentValue = yield* this.pushSpaces(false);
+        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))
+            this.indentNext = this.indentValue;
+        return yield* this.parseBlockStart();
+    }
+    *parseBlockStart() {
+        const [ch0, ch1] = this.peek(2);
+        if (!ch1 && !this.atEnd)
+            return this.setNext('block-start');
+        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {
+            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+            this.indentNext = this.indentValue + 1;
+            this.indentValue += n;
+            return yield* this.parseBlockStart();
+        }
+        return 'doc';
+    }
+    *parseDocument() {
+        yield* this.pushSpaces(true);
+        const line = this.getLine();
+        if (line === null)
+            return this.setNext('doc');
+        let n = yield* this.pushIndicators();
+        switch (line[n]) {
+            case '#':
+                yield* this.pushCount(line.length - n);
+            // fallthrough
+            case undefined:
+                yield* this.pushNewline();
+                return yield* this.parseLineStart();
+            case '{':
+            case '[':
+                yield* this.pushCount(1);
+                this.flowKey = false;
+                this.flowLevel = 1;
+                return 'flow';
+            case '}':
+            case ']':
+                // this is an error
+                yield* this.pushCount(1);
+                return 'doc';
+            case '*':
+                yield* this.pushUntil(isNotAnchorChar);
+                return 'doc';
+            case '"':
+            case "'":
+                return yield* this.parseQuotedScalar();
+            case '|':
+            case '>':
+                n += yield* this.parseBlockScalarHeader();
+                n += yield* this.pushSpaces(true);
+                yield* this.pushCount(line.length - n);
+                yield* this.pushNewline();
+                return yield* this.parseBlockScalar();
+            default:
+                return yield* this.parsePlainScalar();
+        }
+    }
+    *parseFlowCollection() {
+        let nl, sp;
+        let indent = -1;
+        do {
+            nl = yield* this.pushNewline();
+            if (nl > 0) {
+                sp = yield* this.pushSpaces(false);
+                this.indentValue = indent = sp;
+            }
+            else {
+                sp = 0;
+            }
+            sp += yield* this.pushSpaces(true);
+        } while (nl + sp > 0);
+        const line = this.getLine();
+        if (line === null)
+            return this.setNext('flow');
+        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
+            (indent === 0 &&
+                (line.startsWith('---') || line.startsWith('...')) &&
+                isEmpty(line[3]))) {
+            // Allowing for the terminal ] or } at the same (rather than greater)
+            // indent level as the initial [ or { is technically invalid, but
+            // failing here would be surprising to users.
+            const atFlowEndMarker = indent === this.indentNext - 1 &&
+                this.flowLevel === 1 &&
+                (line[0] === ']' || line[0] === '}');
+            if (!atFlowEndMarker) {
+                // this is an error
+                this.flowLevel = 0;
+                yield FLOW_END;
+                return yield* this.parseLineStart();
+            }
+        }
+        let n = 0;
+        while (line[n] === ',') {
+            n += yield* this.pushCount(1);
+            n += yield* this.pushSpaces(true);
+            this.flowKey = false;
+        }
+        n += yield* this.pushIndicators();
+        switch (line[n]) {
+            case undefined:
+                return 'flow';
+            case '#':
+                yield* this.pushCount(line.length - n);
+                return 'flow';
+            case '{':
+            case '[':
+                yield* this.pushCount(1);
+                this.flowKey = false;
+                this.flowLevel += 1;
+                return 'flow';
+            case '}':
+            case ']':
+                yield* this.pushCount(1);
+                this.flowKey = true;
+                this.flowLevel -= 1;
+                return this.flowLevel ? 'flow' : 'doc';
+            case '*':
+                yield* this.pushUntil(isNotAnchorChar);
+                return 'flow';
+            case '"':
+            case "'":
+                this.flowKey = true;
+                return yield* this.parseQuotedScalar();
+            case ':': {
+                const next = this.charAt(1);
+                if (this.flowKey || isEmpty(next) || next === ',') {
+                    this.flowKey = false;
+                    yield* this.pushCount(1);
+                    yield* this.pushSpaces(true);
+                    return 'flow';
+                }
+            }
+            // fallthrough
+            default:
+                this.flowKey = false;
+                return yield* this.parsePlainScalar();
+        }
+    }
+    *parseQuotedScalar() {
+        const quote = this.charAt(0);
+        let end = this.buffer.indexOf(quote, this.pos + 1);
+        if (quote === "'") {
+            while (end !== -1 && this.buffer[end + 1] === "'")
+                end = this.buffer.indexOf("'", end + 2);
+        }
+        else {
+            // double-quote
+            while (end !== -1) {
+                let n = 0;
+                while (this.buffer[end - 1 - n] === '\\')
+                    n += 1;
+                if (n % 2 === 0)
+                    break;
+                end = this.buffer.indexOf('"', end + 1);
+            }
+        }
+        // Only looking for newlines within the quotes
+        const qb = this.buffer.substring(0, end);
+        let nl = qb.indexOf('\n', this.pos);
+        if (nl !== -1) {
+            while (nl !== -1) {
+                const cs = this.continueScalar(nl + 1);
+                if (cs === -1)
+                    break;
+                nl = qb.indexOf('\n', cs);
+            }
+            if (nl !== -1) {
+                // this is an error caused by an unexpected unindent
+                end = nl - (qb[nl - 1] === '\r' ? 2 : 1);
+            }
+        }
+        if (end === -1) {
+            if (!this.atEnd)
+                return this.setNext('quoted-scalar');
+            end = this.buffer.length;
+        }
+        yield* this.pushToIndex(end + 1, false);
+        return this.flowLevel ? 'flow' : 'doc';
+    }
+    *parseBlockScalarHeader() {
+        this.blockScalarIndent = -1;
+        this.blockScalarKeep = false;
+        let i = this.pos;
+        while (true) {
+            const ch = this.buffer[++i];
+            if (ch === '+')
+                this.blockScalarKeep = true;
+            else if (ch > '0' && ch <= '9')
+                this.blockScalarIndent = Number(ch) - 1;
+            else if (ch !== '-')
+                break;
+        }
+        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');
+    }
+    *parseBlockScalar() {
+        let nl = this.pos - 1; // may be -1 if this.pos === 0
+        let indent = 0;
+        let ch;
+        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {
+            switch (ch) {
+                case ' ':
+                    indent += 1;
+                    break;
+                case '\n':
+                    nl = i;
+                    indent = 0;
+                    break;
+                case '\r': {
+                    const next = this.buffer[i + 1];
+                    if (!next && !this.atEnd)
+                        return this.setNext('block-scalar');
+                    if (next === '\n')
+                        break;
+                } // fallthrough
+                default:
+                    break loop;
+            }
+        }
+        if (!ch && !this.atEnd)
+            return this.setNext('block-scalar');
+        if (indent >= this.indentNext) {
+            if (this.blockScalarIndent === -1)
+                this.indentNext = indent;
+            else {
+                this.indentNext =
+                    this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);
+            }
+            do {
+                const cs = this.continueScalar(nl + 1);
+                if (cs === -1)
+                    break;
+                nl = this.buffer.indexOf('\n', cs);
+            } while (nl !== -1);
+            if (nl === -1) {
+                if (!this.atEnd)
+                    return this.setNext('block-scalar');
+                nl = this.buffer.length;
+            }
+        }
+        // Trailing insufficiently indented tabs are invalid.
+        // To catch that during parsing, we include them in the block scalar value.
+        let i = nl + 1;
+        ch = this.buffer[i];
+        while (ch === ' ')
+            ch = this.buffer[++i];
+        if (ch === '\t') {
+            while (ch === '\t' || ch === ' ' || ch === '\r' || ch === '\n')
+                ch = this.buffer[++i];
+            nl = i - 1;
+        }
+        else if (!this.blockScalarKeep) {
+            do {
+                let i = nl - 1;
+                let ch = this.buffer[i];
+                if (ch === '\r')
+                    ch = this.buffer[--i];
+                const lastChar = i; // Drop the line if last char not more indented
+                while (ch === ' ')
+                    ch = this.buffer[--i];
+                if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar)
+                    nl = i;
+                else
+                    break;
+            } while (true);
+        }
+        yield SCALAR;
+        yield* this.pushToIndex(nl + 1, true);
+        return yield* this.parseLineStart();
+    }
+    *parsePlainScalar() {
+        const inFlow = this.flowLevel > 0;
+        let end = this.pos - 1;
+        let i = this.pos - 1;
+        let ch;
+        while ((ch = this.buffer[++i])) {
+            if (ch === ':') {
+                const next = this.buffer[i + 1];
+                if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next)))
+                    break;
+                end = i;
+            }
+            else if (isEmpty(ch)) {
+                let next = this.buffer[i + 1];
+                if (ch === '\r') {
+                    if (next === '\n') {
+                        i += 1;
+                        ch = '\n';
+                        next = this.buffer[i + 1];
+                    }
+                    else
+                        end = i;
+                }
+                if (next === '#' || (inFlow && flowIndicatorChars.has(next)))
+                    break;
+                if (ch === '\n') {
+                    const cs = this.continueScalar(i + 1);
+                    if (cs === -1)
+                        break;
+                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'
+                }
+            }
+            else {
+                if (inFlow && flowIndicatorChars.has(ch))
+                    break;
+                end = i;
+            }
+        }
+        if (!ch && !this.atEnd)
+            return this.setNext('plain-scalar');
+        yield SCALAR;
+        yield* this.pushToIndex(end + 1, true);
+        return inFlow ? 'flow' : 'doc';
+    }
+    *pushCount(n) {
+        if (n > 0) {
+            yield this.buffer.substr(this.pos, n);
+            this.pos += n;
+            return n;
+        }
+        return 0;
+    }
+    *pushToIndex(i, allowEmpty) {
+        const s = this.buffer.slice(this.pos, i);
+        if (s) {
+            yield s;
+            this.pos += s.length;
+            return s.length;
+        }
+        else if (allowEmpty)
+            yield '';
+        return 0;
+    }
+    *pushIndicators() {
+        switch (this.charAt(0)) {
+            case '!':
+                return ((yield* this.pushTag()) +
+                    (yield* this.pushSpaces(true)) +
+                    (yield* this.pushIndicators()));
+            case '&':
+                return ((yield* this.pushUntil(isNotAnchorChar)) +
+                    (yield* this.pushSpaces(true)) +
+                    (yield* this.pushIndicators()));
+            case '-': // this is an error
+            case '?': // this is an error outside flow collections
+            case ':': {
+                const inFlow = this.flowLevel > 0;
+                const ch1 = this.charAt(1);
+                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {
+                    if (!inFlow)
+                        this.indentNext = this.indentValue + 1;
+                    else if (this.flowKey)
+                        this.flowKey = false;
+                    return ((yield* this.pushCount(1)) +
+                        (yield* this.pushSpaces(true)) +
+                        (yield* this.pushIndicators()));
+                }
+            }
+        }
+        return 0;
+    }
+    *pushTag() {
+        if (this.charAt(1) === '<') {
+            let i = this.pos + 2;
+            let ch = this.buffer[i];
+            while (!isEmpty(ch) && ch !== '>')
+                ch = this.buffer[++i];
+            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
+        }
+        else {
+            let i = this.pos + 1;
+            let ch = this.buffer[i];
+            while (ch) {
+                if (tagChars.has(ch))
+                    ch = this.buffer[++i];
+                else if (ch === '%' &&
+                    hexDigits.has(this.buffer[i + 1]) &&
+                    hexDigits.has(this.buffer[i + 2])) {
+                    ch = this.buffer[(i += 3)];
+                }
+                else
+                    break;
+            }
+            return yield* this.pushToIndex(i, false);
+        }
+    }
+    *pushNewline() {
+        const ch = this.buffer[this.pos];
+        if (ch === '\n')
+            return yield* this.pushCount(1);
+        else if (ch === '\r' && this.charAt(1) === '\n')
+            return yield* this.pushCount(2);
+        else
+            return 0;
+    }
+    *pushSpaces(allowTabs) {
+        let i = this.pos - 1;
+        let ch;
+        do {
+            ch = this.buffer[++i];
+        } while (ch === ' ' || (allowTabs && ch === '\t'));
+        const n = i - this.pos;
+        if (n > 0) {
+            yield this.buffer.substr(this.pos, n);
+            this.pos = i;
+        }
+        return n;
+    }
+    *pushUntil(test) {
+        let i = this.pos;
+        let ch = this.buffer[i];
+        while (!test(ch))
+            ch = this.buffer[++i];
+        return yield* this.pushToIndex(i, false);
+    }
+}
+
+export { Lexer };

node_modules/yaml/browser/dist/parse/line-counter.js

@@ -0,0 +1,39 @@
+/**
+ * Tracks newlines during parsing in order to provide an efficient API for
+ * determining the one-indexed `{ line, col }` position for any offset
+ * within the input.
+ */
+class LineCounter {
+    constructor() {
+        this.lineStarts = [];
+        /**
+         * Should be called in ascending order. Otherwise, call
+         * `lineCounter.lineStarts.sort()` before calling `linePos()`.
+         */
+        this.addNewLine = (offset) => this.lineStarts.push(offset);
+        /**
+         * Performs a binary search and returns the 1-indexed { line, col }
+         * position of `offset`. If `line === 0`, `addNewLine` has never been
+         * called or `offset` is before the first known newline.
+         */
+        this.linePos = (offset) => {
+            let low = 0;
+            let high = this.lineStarts.length;
+            while (low < high) {
+                const mid = (low + high) >> 1; // Math.floor((low + high) / 2)
+                if (this.lineStarts[mid] < offset)
+                    low = mid + 1;
+                else
+                    high = mid;
+            }
+            if (this.lineStarts[low] === offset)
+                return { line: low + 1, col: 1 };
+            if (low === 0)
+                return { line: 0, col: offset };
+            const start = this.lineStarts[low - 1];
+            return { line: low, col: offset - start + 1 };
+        };
+    }
+}
+
+export { LineCounter };

node_modules/yaml/browser/dist/parse/parser.js

@@ -0,0 +1,967 @@
+import { tokenType } from './cst.js';
+import { Lexer } from './lexer.js';
+
+function includesToken(list, type) {
+    for (let i = 0; i < list.length; ++i)
+        if (list[i].type === type)
+            return true;
+    return false;
+}
+function findNonEmptyIndex(list) {
+    for (let i = 0; i < list.length; ++i) {
+        switch (list[i].type) {
+            case 'space':
+            case 'comment':
+            case 'newline':
+                break;
+            default:
+                return i;
+        }
+    }
+    return -1;
+}
+function isFlowToken(token) {
+    switch (token?.type) {
+        case 'alias':
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'flow-collection':
+            return true;
+        default:
+            return false;
+    }
+}
+function getPrevProps(parent) {
+    switch (parent.type) {
+        case 'document':
+            return parent.start;
+        case 'block-map': {
+            const it = parent.items[parent.items.length - 1];
+            return it.sep ?? it.start;
+        }
+        case 'block-seq':
+            return parent.items[parent.items.length - 1].start;
+        /* istanbul ignore next should not happen */
+        default:
+            return [];
+    }
+}
+/** Note: May modify input array */
+function getFirstKeyStartProps(prev) {
+    if (prev.length === 0)
+        return [];
+    let i = prev.length;
+    loop: while (--i >= 0) {
+        switch (prev[i].type) {
+            case 'doc-start':
+            case 'explicit-key-ind':
+            case 'map-value-ind':
+            case 'seq-item-ind':
+            case 'newline':
+                break loop;
+        }
+    }
+    while (prev[++i]?.type === 'space') {
+        /* loop */
+    }
+    return prev.splice(i, prev.length);
+}
+function fixFlowSeqItems(fc) {
+    if (fc.start.type === 'flow-seq-start') {
+        for (const it of fc.items) {
+            if (it.sep &&
+                !it.value &&
+                !includesToken(it.start, 'explicit-key-ind') &&
+                !includesToken(it.sep, 'map-value-ind')) {
+                if (it.key)
+                    it.value = it.key;
+                delete it.key;
+                if (isFlowToken(it.value)) {
+                    if (it.value.end)
+                        Array.prototype.push.apply(it.value.end, it.sep);
+                    else
+                        it.value.end = it.sep;
+                }
+                else
+                    Array.prototype.push.apply(it.start, it.sep);
+                delete it.sep;
+            }
+        }
+    }
+}
+/**
+ * A YAML concrete syntax tree (CST) parser
+ *
+ * ```ts
+ * const src: string = ...
+ * for (const token of new Parser().parse(src)) {
+ *   // token: Token
+ * }
+ * ```
+ *
+ * To use the parser with a user-provided lexer:
+ *
+ * ```ts
+ * function* parse(source: string, lexer: Lexer) {
+ *   const parser = new Parser()
+ *   for (const lexeme of lexer.lex(source))
+ *     yield* parser.next(lexeme)
+ *   yield* parser.end()
+ * }
+ *
+ * const src: string = ...
+ * const lexer = new Lexer()
+ * for (const token of parse(src, lexer)) {
+ *   // token: Token
+ * }
+ * ```
+ */
+class Parser {
+    /**
+     * @param onNewLine - If defined, called separately with the start position of
+     *   each new line (in `parse()`, including the start of input).
+     */
+    constructor(onNewLine) {
+        /** If true, space and sequence indicators count as indentation */
+        this.atNewLine = true;
+        /** If true, next token is a scalar value */
+        this.atScalar = false;
+        /** Current indentation level */
+        this.indent = 0;
+        /** Current offset since the start of parsing */
+        this.offset = 0;
+        /** On the same line with a block map key */
+        this.onKeyLine = false;
+        /** Top indicates the node that's currently being built */
+        this.stack = [];
+        /** The source of the current token, set in parse() */
+        this.source = '';
+        /** The type of the current token, set in parse() */
+        this.type = '';
+        // Must be defined after `next()`
+        this.lexer = new Lexer();
+        this.onNewLine = onNewLine;
+    }
+    /**
+     * Parse `source` as a YAML stream.
+     * If `incomplete`, a part of the last line may be left as a buffer for the next call.
+     *
+     * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
+     *
+     * @returns A generator of tokens representing each directive, document, and other structure.
+     */
+    *parse(source, incomplete = false) {
+        if (this.onNewLine && this.offset === 0)
+            this.onNewLine(0);
+        for (const lexeme of this.lexer.lex(source, incomplete))
+            yield* this.next(lexeme);
+        if (!incomplete)
+            yield* this.end();
+    }
+    /**
+     * Advance the parser by the `source` of one lexical token.
+     */
+    *next(source) {
+        this.source = source;
+        if (this.atScalar) {
+            this.atScalar = false;
+            yield* this.step();
+            this.offset += source.length;
+            return;
+        }
+        const type = tokenType(source);
+        if (!type) {
+            const message = `Not a YAML token: ${source}`;
+            yield* this.pop({ type: 'error', offset: this.offset, message, source });
+            this.offset += source.length;
+        }
+        else if (type === 'scalar') {
+            this.atNewLine = false;
+            this.atScalar = true;
+            this.type = 'scalar';
+        }
+        else {
+            this.type = type;
+            yield* this.step();
+            switch (type) {
+                case 'newline':
+                    this.atNewLine = true;
+                    this.indent = 0;
+                    if (this.onNewLine)
+                        this.onNewLine(this.offset + source.length);
+                    break;
+                case 'space':
+                    if (this.atNewLine && source[0] === ' ')
+                        this.indent += source.length;
+                    break;
+                case 'explicit-key-ind':
+                case 'map-value-ind':
+                case 'seq-item-ind':
+                    if (this.atNewLine)
+                        this.indent += source.length;
+                    break;
+                case 'doc-mode':
+                case 'flow-error-end':
+                    return;
+                default:
+                    this.atNewLine = false;
+            }
+            this.offset += source.length;
+        }
+    }
+    /** Call at end of input to push out any remaining constructions */
+    *end() {
+        while (this.stack.length > 0)
+            yield* this.pop();
+    }
+    get sourceToken() {
+        const st = {
+            type: this.type,
+            offset: this.offset,
+            indent: this.indent,
+            source: this.source
+        };
+        return st;
+    }
+    *step() {
+        const top = this.peek(1);
+        if (this.type === 'doc-end' && top?.type !== 'doc-end') {
+            while (this.stack.length > 0)
+                yield* this.pop();
+            this.stack.push({
+                type: 'doc-end',
+                offset: this.offset,
+                source: this.source
+            });
+            return;
+        }
+        if (!top)
+            return yield* this.stream();
+        switch (top.type) {
+            case 'document':
+                return yield* this.document(top);
+            case 'alias':
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return yield* this.scalar(top);
+            case 'block-scalar':
+                return yield* this.blockScalar(top);
+            case 'block-map':
+                return yield* this.blockMap(top);
+            case 'block-seq':
+                return yield* this.blockSequence(top);
+            case 'flow-collection':
+                return yield* this.flowCollection(top);
+            case 'doc-end':
+                return yield* this.documentEnd(top);
+        }
+        /* istanbul ignore next should not happen */
+        yield* this.pop();
+    }
+    peek(n) {
+        return this.stack[this.stack.length - n];
+    }
+    *pop(error) {
+        const token = error ?? this.stack.pop();
+        /* istanbul ignore if should not happen */
+        if (!token) {
+            const message = 'Tried to pop an empty stack';
+            yield { type: 'error', offset: this.offset, source: '', message };
+        }
+        else if (this.stack.length === 0) {
+            yield token;
+        }
+        else {
+            const top = this.peek(1);
+            if (token.type === 'block-scalar') {
+                // Block scalars use their parent rather than header indent
+                token.indent = 'indent' in top ? top.indent : 0;
+            }
+            else if (token.type === 'flow-collection' && top.type === 'document') {
+                // Ignore all indent for top-level flow collections
+                token.indent = 0;
+            }
+            if (token.type === 'flow-collection')
+                fixFlowSeqItems(token);
+            switch (top.type) {
+                case 'document':
+                    top.value = token;
+                    break;
+                case 'block-scalar':
+                    top.props.push(token); // error
+                    break;
+                case 'block-map': {
+                    const it = top.items[top.items.length - 1];
+                    if (it.value) {
+                        top.items.push({ start: [], key: token, sep: [] });
+                        this.onKeyLine = true;
+                        return;
+                    }
+                    else if (it.sep) {
+                        it.value = token;
+                    }
+                    else {
+                        Object.assign(it, { key: token, sep: [] });
+                        this.onKeyLine = !it.explicitKey;
+                        return;
+                    }
+                    break;
+                }
+                case 'block-seq': {
+                    const it = top.items[top.items.length - 1];
+                    if (it.value)
+                        top.items.push({ start: [], value: token });
+                    else
+                        it.value = token;
+                    break;
+                }
+                case 'flow-collection': {
+                    const it = top.items[top.items.length - 1];
+                    if (!it || it.value)
+                        top.items.push({ start: [], key: token, sep: [] });
+                    else if (it.sep)
+                        it.value = token;
+                    else
+                        Object.assign(it, { key: token, sep: [] });
+                    return;
+                }
+                /* istanbul ignore next should not happen */
+                default:
+                    yield* this.pop();
+                    yield* this.pop(token);
+            }
+            if ((top.type === 'document' ||
+                top.type === 'block-map' ||
+                top.type === 'block-seq') &&
+                (token.type === 'block-map' || token.type === 'block-seq')) {
+                const last = token.items[token.items.length - 1];
+                if (last &&
+                    !last.sep &&
+                    !last.value &&
+                    last.start.length > 0 &&
+                    findNonEmptyIndex(last.start) === -1 &&
+                    (token.indent === 0 ||
+                        last.start.every(st => st.type !== 'comment' || st.indent < token.indent))) {
+                    if (top.type === 'document')
+                        top.end = last.start;
+                    else
+                        top.items.push({ start: last.start });
+                    token.items.splice(-1, 1);
+                }
+            }
+        }
+    }
+    *stream() {
+        switch (this.type) {
+            case 'directive-line':
+                yield { type: 'directive', offset: this.offset, source: this.source };
+                return;
+            case 'byte-order-mark':
+            case 'space':
+            case 'comment':
+            case 'newline':
+                yield this.sourceToken;
+                return;
+            case 'doc-mode':
+            case 'doc-start': {
+                const doc = {
+                    type: 'document',
+                    offset: this.offset,
+                    start: []
+                };
+                if (this.type === 'doc-start')
+                    doc.start.push(this.sourceToken);
+                this.stack.push(doc);
+                return;
+            }
+        }
+        yield {
+            type: 'error',
+            offset: this.offset,
+            message: `Unexpected ${this.type} token in YAML stream`,
+            source: this.source
+        };
+    }
+    *document(doc) {
+        if (doc.value)
+            return yield* this.lineEnd(doc);
+        switch (this.type) {
+            case 'doc-start': {
+                if (findNonEmptyIndex(doc.start) !== -1) {
+                    yield* this.pop();
+                    yield* this.step();
+                }
+                else
+                    doc.start.push(this.sourceToken);
+                return;
+            }
+            case 'anchor':
+            case 'tag':
+            case 'space':
+            case 'comment':
+            case 'newline':
+                doc.start.push(this.sourceToken);
+                return;
+        }
+        const bv = this.startBlockValue(doc);
+        if (bv)
+            this.stack.push(bv);
+        else {
+            yield {
+                type: 'error',
+                offset: this.offset,
+                message: `Unexpected ${this.type} token in YAML document`,
+                source: this.source
+            };
+        }
+    }
+    *scalar(scalar) {
+        if (this.type === 'map-value-ind') {
+            const prev = getPrevProps(this.peek(2));
+            const start = getFirstKeyStartProps(prev);
+            let sep;
+            if (scalar.end) {
+                sep = scalar.end;
+                sep.push(this.sourceToken);
+                delete scalar.end;
+            }
+            else
+                sep = [this.sourceToken];
+            const map = {
+                type: 'block-map',
+                offset: scalar.offset,
+                indent: scalar.indent,
+                items: [{ start, key: scalar, sep }]
+            };
+            this.onKeyLine = true;
+            this.stack[this.stack.length - 1] = map;
+        }
+        else
+            yield* this.lineEnd(scalar);
+    }
+    *blockScalar(scalar) {
+        switch (this.type) {
+            case 'space':
+            case 'comment':
+            case 'newline':
+                scalar.props.push(this.sourceToken);
+                return;
+            case 'scalar':
+                scalar.source = this.source;
+                // block-scalar source includes trailing newline
+                this.atNewLine = true;
+                this.indent = 0;
+                if (this.onNewLine) {
+                    let nl = this.source.indexOf('\n') + 1;
+                    while (nl !== 0) {
+                        this.onNewLine(this.offset + nl);
+                        nl = this.source.indexOf('\n', nl) + 1;
+                    }
+                }
+                yield* this.pop();
+                break;
+            /* istanbul ignore next should not happen */
+            default:
+                yield* this.pop();
+                yield* this.step();
+        }
+    }
+    *blockMap(map) {
+        const it = map.items[map.items.length - 1];
+        // it.sep is true-ish if pair already has key or : separator
+        switch (this.type) {
+            case 'newline':
+                this.onKeyLine = false;
+                if (it.value) {
+                    const end = 'end' in it.value ? it.value.end : undefined;
+                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
+                    else
+                        map.items.push({ start: [this.sourceToken] });
+                }
+                else if (it.sep) {
+                    it.sep.push(this.sourceToken);
+                }
+                else {
+                    it.start.push(this.sourceToken);
+                }
+                return;
+            case 'space':
+            case 'comment':
+                if (it.value) {
+                    map.items.push({ start: [this.sourceToken] });
+                }
+                else if (it.sep) {
+                    it.sep.push(this.sourceToken);
+                }
+                else {
+                    if (this.atIndentedComment(it.start, map.indent)) {
+                        const prev = map.items[map.items.length - 2];
+                        const end = prev?.value?.end;
+                        if (Array.isArray(end)) {
+                            Array.prototype.push.apply(end, it.start);
+                            end.push(this.sourceToken);
+                            map.items.pop();
+                            return;
+                        }
+                    }
+                    it.start.push(this.sourceToken);
+                }
+                return;
+        }
+        if (this.indent >= map.indent) {
+            const atMapIndent = !this.onKeyLine && this.indent === map.indent;
+            const atNextItem = atMapIndent &&
+                (it.sep || it.explicitKey) &&
+                this.type !== 'seq-item-ind';
+            // For empty nodes, assign newline-separated not indented empty tokens to following node
+            let start = [];
+            if (atNextItem && it.sep && !it.value) {
+                const nl = [];
+                for (let i = 0; i < it.sep.length; ++i) {
+                    const st = it.sep[i];
+                    switch (st.type) {
+                        case 'newline':
+                            nl.push(i);
+                            break;
+                        case 'space':
+                            break;
+                        case 'comment':
+                            if (st.indent > map.indent)
+                                nl.length = 0;
+                            break;
+                        default:
+                            nl.length = 0;
+                    }
+                }
+                if (nl.length >= 2)
+                    start = it.sep.splice(nl[1]);
+            }
+            switch (this.type) {
+                case 'anchor':
+                case 'tag':
+                    if (atNextItem || it.value) {
+                        start.push(this.sourceToken);
+                        map.items.push({ start });
+                        this.onKeyLine = true;
+                    }
+                    else if (it.sep) {
+                        it.sep.push(this.sourceToken);
+                    }
+                    else {
+                        it.start.push(this.sourceToken);
+                    }
+                    return;
+                case 'explicit-key-ind':
+                    if (!it.sep && !it.explicitKey) {
+                        it.start.push(this.sourceToken);
+                        it.explicitKey = true;
+                    }
+                    else if (atNextItem || it.value) {
+                        start.push(this.sourceToken);
+                        map.items.push({ start, explicitKey: true });
+                    }
+                    else {
+                        this.stack.push({
+                            type: 'block-map',
+                            offset: this.offset,
+                            indent: this.indent,
+                            items: [{ start: [this.sourceToken], explicitKey: true }]
+                        });
+                    }
+                    this.onKeyLine = true;
+                    return;
+                case 'map-value-ind':
+                    if (it.explicitKey) {
+                        if (!it.sep) {
+                            if (includesToken(it.start, 'newline')) {
+                                Object.assign(it, { key: null, sep: [this.sourceToken] });
+                            }
+                            else {
+                                const start = getFirstKeyStartProps(it.start);
+                                this.stack.push({
+                                    type: 'block-map',
+                                    offset: this.offset,
+                                    indent: this.indent,
+                                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                                });
+                            }
+                        }
+                        else if (it.value) {
+                            map.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else if (isFlowToken(it.key) &&
+                            !includesToken(it.sep, 'newline')) {
+                            const start = getFirstKeyStartProps(it.start);
+                            const key = it.key;
+                            const sep = it.sep;
+                            sep.push(this.sourceToken);
+                            // @ts-expect-error type guard is wrong here
+                            delete it.key;
+                            // @ts-expect-error type guard is wrong here
+                            delete it.sep;
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key, sep }]
+                            });
+                        }
+                        else if (start.length > 0) {
+                            // Not actually at next item
+                            it.sep = it.sep.concat(start, this.sourceToken);
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    else {
+                        if (!it.sep) {
+                            Object.assign(it, { key: null, sep: [this.sourceToken] });
+                        }
+                        else if (it.value || atNextItem) {
+                            map.items.push({ start, key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start: [], key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    this.onKeyLine = true;
+                    return;
+                case 'alias':
+                case 'scalar':
+                case 'single-quoted-scalar':
+                case 'double-quoted-scalar': {
+                    const fs = this.flowScalar(this.type);
+                    if (atNextItem || it.value) {
+                        map.items.push({ start, key: fs, sep: [] });
+                        this.onKeyLine = true;
+                    }
+                    else if (it.sep) {
+                        this.stack.push(fs);
+                    }
+                    else {
+                        Object.assign(it, { key: fs, sep: [] });
+                        this.onKeyLine = true;
+                    }
+                    return;
+                }
+                default: {
+                    const bv = this.startBlockValue(map);
+                    if (bv) {
+                        if (bv.type === 'block-seq') {
+                            if (!it.explicitKey &&
+                                it.sep &&
+                                !includesToken(it.sep, 'newline')) {
+                                yield* this.pop({
+                                    type: 'error',
+                                    offset: this.offset,
+                                    message: 'Unexpected block-seq-ind on same line with key',
+                                    source: this.source
+                                });
+                                return;
+                            }
+                        }
+                        else if (atMapIndent) {
+                            map.items.push({ start });
+                        }
+                        this.stack.push(bv);
+                        return;
+                    }
+                }
+            }
+        }
+        yield* this.pop();
+        yield* this.step();
+    }
+    *blockSequence(seq) {
+        const it = seq.items[seq.items.length - 1];
+        switch (this.type) {
+            case 'newline':
+                if (it.value) {
+                    const end = 'end' in it.value ? it.value.end : undefined;
+                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
+                    else
+                        seq.items.push({ start: [this.sourceToken] });
+                }
+                else
+                    it.start.push(this.sourceToken);
+                return;
+            case 'space':
+            case 'comment':
+                if (it.value)
+                    seq.items.push({ start: [this.sourceToken] });
+                else {
+                    if (this.atIndentedComment(it.start, seq.indent)) {
+                        const prev = seq.items[seq.items.length - 2];
+                        const end = prev?.value?.end;
+                        if (Array.isArray(end)) {
+                            Array.prototype.push.apply(end, it.start);
+                            end.push(this.sourceToken);
+                            seq.items.pop();
+                            return;
+                        }
+                    }
+                    it.start.push(this.sourceToken);
+                }
+                return;
+            case 'anchor':
+            case 'tag':
+                if (it.value || this.indent <= seq.indent)
+                    break;
+                it.start.push(this.sourceToken);
+                return;
+            case 'seq-item-ind':
+                if (this.indent !== seq.indent)
+                    break;
+                if (it.value || includesToken(it.start, 'seq-item-ind'))
+                    seq.items.push({ start: [this.sourceToken] });
+                else
+                    it.start.push(this.sourceToken);
+                return;
+        }
+        if (this.indent > seq.indent) {
+            const bv = this.startBlockValue(seq);
+            if (bv) {
+                this.stack.push(bv);
+                return;
+            }
+        }
+        yield* this.pop();
+        yield* this.step();
+    }
+    *flowCollection(fc) {
+        const it = fc.items[fc.items.length - 1];
+        if (this.type === 'flow-error-end') {
+            let top;
+            do {
+                yield* this.pop();
+                top = this.peek(1);
+            } while (top?.type === 'flow-collection');
+        }
+        else if (fc.end.length === 0) {
+            switch (this.type) {
+                case 'comma':
+                case 'explicit-key-ind':
+                    if (!it || it.sep)
+                        fc.items.push({ start: [this.sourceToken] });
+                    else
+                        it.start.push(this.sourceToken);
+                    return;
+                case 'map-value-ind':
+                    if (!it || it.value)
+                        fc.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                    else if (it.sep)
+                        it.sep.push(this.sourceToken);
+                    else
+                        Object.assign(it, { key: null, sep: [this.sourceToken] });
+                    return;
+                case 'space':
+                case 'comment':
+                case 'newline':
+                case 'anchor':
+                case 'tag':
+                    if (!it || it.value)
+                        fc.items.push({ start: [this.sourceToken] });
+                    else if (it.sep)
+                        it.sep.push(this.sourceToken);
+                    else
+                        it.start.push(this.sourceToken);
+                    return;
+                case 'alias':
+                case 'scalar':
+                case 'single-quoted-scalar':
+                case 'double-quoted-scalar': {
+                    const fs = this.flowScalar(this.type);
+                    if (!it || it.value)
+                        fc.items.push({ start: [], key: fs, sep: [] });
+                    else if (it.sep)
+                        this.stack.push(fs);
+                    else
+                        Object.assign(it, { key: fs, sep: [] });
+                    return;
+                }
+                case 'flow-map-end':
+                case 'flow-seq-end':
+                    fc.end.push(this.sourceToken);
+                    return;
+            }
+            const bv = this.startBlockValue(fc);
+            /* istanbul ignore else should not happen */
+            if (bv)
+                this.stack.push(bv);
+            else {
+                yield* this.pop();
+                yield* this.step();
+            }
+        }
+        else {
+            const parent = this.peek(2);
+            if (parent.type === 'block-map' &&
+                ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
+                    (this.type === 'newline' &&
+                        !parent.items[parent.items.length - 1].sep))) {
+                yield* this.pop();
+                yield* this.step();
+            }
+            else if (this.type === 'map-value-ind' &&
+                parent.type !== 'flow-collection') {
+                const prev = getPrevProps(parent);
+                const start = getFirstKeyStartProps(prev);
+                fixFlowSeqItems(fc);
+                const sep = fc.end.splice(1, fc.end.length);
+                sep.push(this.sourceToken);
+                const map = {
+                    type: 'block-map',
+                    offset: fc.offset,
+                    indent: fc.indent,
+                    items: [{ start, key: fc, sep }]
+                };
+                this.onKeyLine = true;
+                this.stack[this.stack.length - 1] = map;
+            }
+            else {
+                yield* this.lineEnd(fc);
+            }
+        }
+    }
+    flowScalar(type) {
+        if (this.onNewLine) {
+            let nl = this.source.indexOf('\n') + 1;
+            while (nl !== 0) {
+                this.onNewLine(this.offset + nl);
+                nl = this.source.indexOf('\n', nl) + 1;
+            }
+        }
+        return {
+            type,
+            offset: this.offset,
+            indent: this.indent,
+            source: this.source
+        };
+    }
+    startBlockValue(parent) {
+        switch (this.type) {
+            case 'alias':
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return this.flowScalar(this.type);
+            case 'block-scalar-header':
+                return {
+                    type: 'block-scalar',
+                    offset: this.offset,
+                    indent: this.indent,
+                    props: [this.sourceToken],
+                    source: ''
+                };
+            case 'flow-map-start':
+            case 'flow-seq-start':
+                return {
+                    type: 'flow-collection',
+                    offset: this.offset,
+                    indent: this.indent,
+                    start: this.sourceToken,
+                    items: [],
+                    end: []
+                };
+            case 'seq-item-ind':
+                return {
+                    type: 'block-seq',
+                    offset: this.offset,
+                    indent: this.indent,
+                    items: [{ start: [this.sourceToken] }]
+                };
+            case 'explicit-key-ind': {
+                this.onKeyLine = true;
+                const prev = getPrevProps(parent);
+                const start = getFirstKeyStartProps(prev);
+                start.push(this.sourceToken);
+                return {
+                    type: 'block-map',
+                    offset: this.offset,
+                    indent: this.indent,
+                    items: [{ start, explicitKey: true }]
+                };
+            }
+            case 'map-value-ind': {
+                this.onKeyLine = true;
+                const prev = getPrevProps(parent);
+                const start = getFirstKeyStartProps(prev);
+                return {
+                    type: 'block-map',
+                    offset: this.offset,
+                    indent: this.indent,
+                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                };
+            }
+        }
+        return null;
+    }
+    atIndentedComment(start, indent) {
+        if (this.type !== 'comment')
+            return false;
+        if (this.indent <= indent)
+            return false;
+        return start.every(st => st.type === 'newline' || st.type === 'space');
+    }
+    *documentEnd(docEnd) {
+        if (this.type !== 'doc-mode') {
+            if (docEnd.end)
+                docEnd.end.push(this.sourceToken);
+            else
+                docEnd.end = [this.sourceToken];
+            if (this.type === 'newline')
+                yield* this.pop();
+        }
+    }
+    *lineEnd(token) {
+        switch (this.type) {
+            case 'comma':
+            case 'doc-start':
+            case 'doc-end':
+            case 'flow-seq-end':
+            case 'flow-map-end':
+            case 'map-value-ind':
+                yield* this.pop();
+                yield* this.step();
+                break;
+            case 'newline':
+                this.onKeyLine = false;
+            // fallthrough
+            case 'space':
+            case 'comment':
+            default:
+                // all other values are errors
+                if (token.end)
+                    token.end.push(this.sourceToken);
+                else
+                    token.end = [this.sourceToken];
+                if (this.type === 'newline')
+                    yield* this.pop();
+        }
+    }
+}
+
+export { Parser };

node_modules/yaml/browser/dist/public-api.js

@@ -0,0 +1,102 @@
+import { Composer } from './compose/composer.js';
+import { Document } from './doc/Document.js';
+import { prettifyError, YAMLParseError } from './errors.js';
+import { warn } from './log.js';
+import { isDocument } from './nodes/identity.js';
+import { LineCounter } from './parse/line-counter.js';
+import { Parser } from './parse/parser.js';
+
+function parseOptions(options) {
+    const prettyErrors = options.prettyErrors !== false;
+    const lineCounter = options.lineCounter || (prettyErrors && new LineCounter()) || null;
+    return { lineCounter, prettyErrors };
+}
+/**
+ * Parse the input as a stream of YAML documents.
+ *
+ * Documents should be separated from each other by `...` or `---` marker lines.
+ *
+ * @returns If an empty `docs` array is returned, it will be of type
+ *   EmptyStream and contain additional stream information. In
+ *   TypeScript, you should use `'empty' in docs` as a type guard for it.
+ */
+function parseAllDocuments(source, options = {}) {
+    const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser = new Parser(lineCounter?.addNewLine);
+    const composer = new Composer(options);
+    const docs = Array.from(composer.compose(parser.parse(source)));
+    if (prettyErrors && lineCounter)
+        for (const doc of docs) {
+            doc.errors.forEach(prettifyError(source, lineCounter));
+            doc.warnings.forEach(prettifyError(source, lineCounter));
+        }
+    if (docs.length > 0)
+        return docs;
+    return Object.assign([], { empty: true }, composer.streamInfo());
+}
+/** Parse an input string into a single YAML.Document */
+function parseDocument(source, options = {}) {
+    const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser = new Parser(lineCounter?.addNewLine);
+    const composer = new Composer(options);
+    // `doc` is always set by compose.end(true) at the very latest
+    let doc = null;
+    for (const _doc of composer.compose(parser.parse(source), true, source.length)) {
+        if (!doc)
+            doc = _doc;
+        else if (doc.options.logLevel !== 'silent') {
+            doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
+            break;
+        }
+    }
+    if (prettyErrors && lineCounter) {
+        doc.errors.forEach(prettifyError(source, lineCounter));
+        doc.warnings.forEach(prettifyError(source, lineCounter));
+    }
+    return doc;
+}
+function parse(src, reviver, options) {
+    let _reviver = undefined;
+    if (typeof reviver === 'function') {
+        _reviver = reviver;
+    }
+    else if (options === undefined && reviver && typeof reviver === 'object') {
+        options = reviver;
+    }
+    const doc = parseDocument(src, options);
+    if (!doc)
+        return null;
+    doc.warnings.forEach(warning => warn(doc.options.logLevel, warning));
+    if (doc.errors.length > 0) {
+        if (doc.options.logLevel !== 'silent')
+            throw doc.errors[0];
+        else
+            doc.errors = [];
+    }
+    return doc.toJS(Object.assign({ reviver: _reviver }, options));
+}
+function stringify(value, replacer, options) {
+    let _replacer = null;
+    if (typeof replacer === 'function' || Array.isArray(replacer)) {
+        _replacer = replacer;
+    }
+    else if (options === undefined && replacer) {
+        options = replacer;
+    }
+    if (typeof options === 'string')
+        options = options.length;
+    if (typeof options === 'number') {
+        const indent = Math.round(options);
+        options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent };
+    }
+    if (value === undefined) {
+        const { keepUndefined } = options ?? replacer ?? {};
+        if (!keepUndefined)
+            return undefined;
+    }
+    if (isDocument(value) && !_replacer)
+        return value.toString(options);
+    return new Document(value, _replacer, options).toString(options);
+}
+
+export { parse, parseAllDocuments, parseDocument, stringify };

node_modules/yaml/browser/dist/schema/Schema.js

@@ -0,0 +1,37 @@
+import { MAP, SCALAR, SEQ } from '../nodes/identity.js';
+import { map } from './common/map.js';
+import { seq } from './common/seq.js';
+import { string } from './common/string.js';
+import { getTags, coreKnownTags } from './tags.js';
+
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+class Schema {
+    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+        this.compat = Array.isArray(compat)
+            ? getTags(compat, 'compat')
+            : compat
+                ? getTags(null, compat)
+                : null;
+        this.name = (typeof schema === 'string' && schema) || 'core';
+        this.knownTags = resolveKnownTags ? coreKnownTags : {};
+        this.tags = getTags(customTags, this.name, merge);
+        this.toStringOptions = toStringDefaults ?? null;
+        Object.defineProperty(this, MAP, { value: map });
+        Object.defineProperty(this, SCALAR, { value: string });
+        Object.defineProperty(this, SEQ, { value: seq });
+        // Used by createMap()
+        this.sortMapEntries =
+            typeof sortMapEntries === 'function'
+                ? sortMapEntries
+                : sortMapEntries === true
+                    ? sortMapEntriesByKey
+                    : null;
+    }
+    clone() {
+        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        copy.tags = this.tags.slice();
+        return copy;
+    }
+}
+
+export { Schema };

node_modules/yaml/browser/dist/schema/common/map.js

@@ -0,0 +1,17 @@
+import { isMap } from '../../nodes/identity.js';
+import { YAMLMap } from '../../nodes/YAMLMap.js';
+
+const map = {
+    collection: 'map',
+    default: true,
+    nodeClass: YAMLMap,
+    tag: 'tag:yaml.org,2002:map',
+    resolve(map, onError) {
+        if (!isMap(map))
+            onError('Expected a mapping for this tag');
+        return map;
+    },
+    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
+};
+
+export { map };

node_modules/yaml/browser/dist/schema/common/null.js

@@ -0,0 +1,15 @@
+import { Scalar } from '../../nodes/Scalar.js';
+
+const nullTag = {
+    identify: value => value == null,
+    createNode: () => new Scalar(null),
+    default: true,
+    tag: 'tag:yaml.org,2002:null',
+    test: /^(?:~|[Nn]ull|NULL)?$/,
+    resolve: () => new Scalar(null),
+    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)
+        ? source
+        : ctx.options.nullStr
+};
+
+export { nullTag };

node_modules/yaml/browser/dist/schema/common/seq.js

@@ -0,0 +1,17 @@
+import { isSeq } from '../../nodes/identity.js';
+import { YAMLSeq } from '../../nodes/YAMLSeq.js';
+
+const seq = {
+    collection: 'seq',
+    default: true,
+    nodeClass: YAMLSeq,
+    tag: 'tag:yaml.org,2002:seq',
+    resolve(seq, onError) {
+        if (!isSeq(seq))
+            onError('Expected a sequence for this tag');
+        return seq;
+    },
+    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
+};
+
+export { seq };

node_modules/yaml/browser/dist/schema/common/string.js

@@ -0,0 +1,14 @@
+import { stringifyString } from '../../stringify/stringifyString.js';
+
+const string = {
+    identify: value => typeof value === 'string',
+    default: true,
+    tag: 'tag:yaml.org,2002:str',
+    resolve: str => str,
+    stringify(item, ctx, onComment, onChompKeep) {
+        ctx = Object.assign({ actualString: true }, ctx);
+        return stringifyString(item, ctx, onComment, onChompKeep);
+    }
+};
+
+export { string };

node_modules/yaml/browser/dist/schema/core/bool.js

@@ -0,0 +1,19 @@
+import { Scalar } from '../../nodes/Scalar.js';
+
+const boolTag = {
+    identify: value => typeof value === 'boolean',
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),
+    stringify({ source, value }, ctx) {
+        if (source && boolTag.test.test(source)) {
+            const sv = source[0] === 't' || source[0] === 'T';
+            if (value === sv)
+                return source;
+        }
+        return value ? ctx.options.trueStr : ctx.options.falseStr;
+    }
+};
+
+export { boolTag };

node_modules/yaml/browser/dist/schema/core/float.js

@@ -0,0 +1,43 @@
+import { Scalar } from '../../nodes/Scalar.js';
+import { stringifyNumber } from '../../stringify/stringifyNumber.js';
+
+const floatNaN = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+    resolve: str => str.slice(-3).toLowerCase() === 'nan'
+        ? NaN
+        : str[0] === '-'
+            ? Number.NEGATIVE_INFINITY
+            : Number.POSITIVE_INFINITY,
+    stringify: stringifyNumber
+};
+const floatExp = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    format: 'EXP',
+    test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+    resolve: str => parseFloat(str),
+    stringify(node) {
+        const num = Number(node.value);
+        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+    }
+};
+const float = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+    resolve(str) {
+        const node = new Scalar(parseFloat(str));
+        const dot = str.indexOf('.');
+        if (dot !== -1 && str[str.length - 1] === '0')
+            node.minFractionDigits = str.length - dot - 1;
+        return node;
+    },
+    stringify: stringifyNumber
+};
+
+export { float, floatExp, floatNaN };