feat: add convex backend skill and fix seo incident/local audit

Made-with: Cursor
2026-02-27 08:39:50 +01:00
parent d8f67c250e
commit b06ee9ee23
9 changed files with 979 additions and 13 deletions
--- a/CATALOG.md
+++ b/CATALOG.md
@@ -2,7 +2,7 @@

 Generated at: 2026-02-08T00:00:00.000Z

-Total skills: 947
+Total skills: 951

 ## architecture (73)

@@ -102,7 +102,7 @@ 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 (42)
+## business (43)

 | Skill | Description | Tags | Triggers |
 | --- | --- | --- | --- |
@@ -129,6 +129,7 @@ the relationship be... | driven | driven, context, development, skill, working,
 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 |
 | `linkedin-cli` | Use when automating LinkedIn via CLI: fetch profiles, search people/companies, send messages, manage connections, create posts, and Sales Navigator. | linkedin, cli | linkedin, cli, automating, via, fetch, profiles, search, people, companies, send, messages, connections |
+| `local-legal-seo-audit` | Audit and improve local SEO for law firms, attorneys, forensic experts and legal/professional services sites with local presence, focusing on GBP, directorie... | local, legal, seo, audit | local, legal, seo, audit, improve, law, firms, attorneys, forensic, experts, professional, sites |
 | `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", "w... | market, sizing | market, sizing, analysis, skill, should, used, user, asks, calculate, tam, determine, sam |
@@ -925,7 +926,7 @@ cross-platform de... | unity | unity, developer, games, optimized, scripts, effi
 | `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, analysis, skill, should, used, user, asks, analyze, network, traffic, 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 |

-## security (125)
+## security (128)

 | Skill | Description | Tags | Triggers |
 | --- | --- | --- | --- |
@@ -964,6 +965,7 @@ optimization, and ... | cloud | cloud, architect, specializing, aws, azure, gcp,
 | `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 |
+| `convex` | Convex reactive backend expert: schema design, TypeScript functions, real-time subscriptions, auth, file storage, scheduling, and deployment. | convex | convex, reactive, backend, schema, typescript, functions, real, time, subscriptions, auth, file, storage |
 | `crypto-bd-agent` | Autonomous crypto business development patterns — multi-chain token discovery, 100-point scoring with wallet forensics, x402 micropayments, ERC-8004 on-chain... | crypto, business-development, token-scanning, x402, erc-8004, autonomous-agent, solana, ethereum, wallet-forensics | crypto, business-development, token-scanning, x402, erc-8004, autonomous-agent, solana, ethereum, wallet-forensics, bd, agent, autonomous |
 | `customs-trade-compliance` | Codified expertise for customs documentation, tariff classification, duty optimisation, restricted party screening, and regulatory compliance across multiple... | customs, trade, compliance | customs, trade, compliance, codified, expertise, documentation, tariff, classification, duty, optimisation, restricted, party |
 | `database-admin` | Expert database administrator specializing in modern cloud
@@ -1084,10 +1086,12 @@ analysis across multiple languages and frameworks | security, scanning, sast | s
 | `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 |
+| `seo-forensic-incident-response` | Investigate sudden drops in organic traffic or rankings and run a structured forensic SEO incident response with triage, root-cause analysis and recovery plan. | seo, forensic, incident, response | seo, forensic, incident, response, investigate, sudden, drops, organic, traffic, rankings, run, structured |
 | `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 |
 | `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 |
 | `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 |
+| `temporal-golang-pro` | Use when building durable distributed systems with Temporal Go SDK. Covers deterministic workflow rules, mTLS worker configs, and advanced patterns. | temporal, golang | temporal, golang, pro, building, durable, distributed, go, sdk, covers, deterministic, rules, mtls |
 | `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 |
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# 🌌 Antigravity Awesome Skills: 946+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More
+# 🌌 Antigravity Awesome Skills: 950+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More

-> **The Ultimate Collection of 946+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode, AdaL**
+> **The Ultimate Collection of 950+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode, AdaL**

 [![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)
@@ -17,7 +17,7 @@

 If this project helps you, you can [support it here](https://buymeacoffee.com/sickn33) or simply ⭐ the repo.

-**Antigravity Awesome Skills** is a curated, battle-tested library of **946 high-performance agentic skills** designed to work seamlessly across all major AI coding assistants:
+**Antigravity Awesome Skills** is a curated, battle-tested library of **950 high-performance agentic skills** designed to work seamlessly across all major AI coding assistants:

 - 🟣 **Claude Code** (Anthropic CLI)
 - 🔵 **Gemini CLI** (Google DeepMind)
@@ -42,7 +42,7 @@ This repository provides essential skills to transform your AI assistant into a
 - [🎁 Curated Collections (Bundles)](#curated-collections)
 - [🧭 Antigravity Workflows](#antigravity-workflows)
 - [📦 Features & Categories](#features--categories)
- [📚 Browse 946+ Skills](#browse-946-skills)
+- [📚 Browse 950+ Skills](#browse-950-skills)
 - [🤝 How to Contribute](#how-to-contribute)
 - [🤝 Community](#community)
 - [☕ Support the Project](#support-the-project)
@@ -345,7 +345,7 @@ The repository is organized into specialized domains to transform your AI into a

 Counts change as new skills are added. For the current full registry, see [CATALOG.md](CATALOG.md).

-## Browse 946+ Skills
+## Browse 950+ Skills

 We have moved the full skill registry to a dedicated catalog to keep this README clean, and we've also introduced an interactive **Web App**!

--- a/data/aliases.json
+++ b/data/aliases.json
@@ -105,6 +105,7 @@
    "security/aws-iam-practices": "security/aws-iam-best-practices",
    "aws-secrets-rotation": "security/aws-secrets-rotation",
    "aws-security-audit": "security/aws-security-audit",
+    "seo-forensic-response": "seo-forensic-incident-response",
    "startup-business-case": "startup-business-analyst-business-case",
    "startup-business-projections": "startup-business-analyst-financial-projections",
    "startup-business-opportunity": "startup-business-analyst-market-opportunity",
--- a/data/bundles.json
+++ b/data/bundles.json
@@ -122,6 +122,7 @@
        "cdk-patterns",
        "code-documentation-doc-generate",
        "context7-auto-research",
+        "convex",
        "copilot-sdk",
        "dbos-golang",
        "dbos-python",
@@ -228,6 +229,7 @@
        "tavily-web",
        "telegram-bot-builder",
        "telegram-mini-app",
+        "temporal-golang-pro",
        "temporal-python-pro",
        "temporal-python-testing",
        "trigger-dev",
@@ -275,6 +277,7 @@
        "code-review-checklist",
        "code-reviewer",
        "codebase-cleanup-deps-audit",
+        "convex",
        "customs-trade-compliance",
        "database-admin",
        "dependency-management-deps-audit",
@@ -530,6 +533,7 @@
        "cicd-automation-workflow-automate",
        "cloud-devops",
        "code-review-ai-ai-review",
+        "convex",
        "crypto-bd-agent",
        "data-engineer",
        "data-engineering-data-pipeline",
@@ -583,6 +587,7 @@
        "prometheus-configuration",
        "risk-metrics-calculation",
        "security-auditor",
+        "seo-forensic-incident-response",
        "server-management",
        "service-mesh-expert",
        "service-mesh-observability",
--- a/data/catalog.json
+++ b/data/catalog.json
@@ -1,6 +1,6 @@
 {
  "generatedAt": "2026-02-08T00:00:00.000Z",
-  "total": 947,
+  "total": 951,
  "skills": [
    {
      "id": "00-andruia-consultant",
@@ -7823,6 +7823,30 @@
      ],
      "path": "skills/convertkit-automation/SKILL.md"
    },
+    {
+      "id": "convex",
+      "name": "convex",
+      "description": "Convex reactive backend expert: schema design, TypeScript functions, real-time subscriptions, auth, file storage, scheduling, and deployment.",
+      "category": "security",
+      "tags": [
+        "convex"
+      ],
+      "triggers": [
+        "convex",
+        "reactive",
+        "backend",
+        "schema",
+        "typescript",
+        "functions",
+        "real",
+        "time",
+        "subscriptions",
+        "auth",
+        "file",
+        "storage"
+      ],
+      "path": "skills/convex/SKILL.md"
+    },
    {
      "id": "copilot-sdk",
      "name": "copilot-sdk",
@@ -14351,6 +14375,33 @@
      ],
      "path": "skills/llm-evaluation/SKILL.md"
    },
+    {
+      "id": "local-legal-seo-audit",
+      "name": "local-legal-seo-audit",
+      "description": "Audit and improve local SEO for law firms, attorneys, forensic experts and legal/professional services sites with local presence, focusing on GBP, directories, E-E-A-T and practice/location pages.",
+      "category": "business",
+      "tags": [
+        "local",
+        "legal",
+        "seo",
+        "audit"
+      ],
+      "triggers": [
+        "local",
+        "legal",
+        "seo",
+        "audit",
+        "improve",
+        "law",
+        "firms",
+        "attorneys",
+        "forensic",
+        "experts",
+        "professional",
+        "sites"
+      ],
+      "path": "skills/local-legal-seo-audit/SKILL.md"
+    },
    {
      "id": "logistics-exception-management",
      "name": "logistics-exception-management",
@@ -19442,6 +19493,33 @@
      ],
      "path": "skills/seo-content-writer/SKILL.md"
    },
+    {
+      "id": "seo-forensic-incident-response",
+      "name": "seo-forensic-incident-response",
+      "description": "Investigate sudden drops in organic traffic or rankings and run a structured forensic SEO incident response with triage, root-cause analysis and recovery plan.",
+      "category": "security",
+      "tags": [
+        "seo",
+        "forensic",
+        "incident",
+        "response"
+      ],
+      "triggers": [
+        "seo",
+        "forensic",
+        "incident",
+        "response",
+        "investigate",
+        "sudden",
+        "drops",
+        "organic",
+        "traffic",
+        "rankings",
+        "run",
+        "structured"
+      ],
+      "path": "skills/seo-forensic-incident-response/SKILL.md"
+    },
    {
      "id": "seo-fundamentals",
      "name": "seo-fundamentals",
@@ -21100,6 +21178,31 @@
      ],
      "path": "skills/telegram-mini-app/SKILL.md"
    },
+    {
+      "id": "temporal-golang-pro",
+      "name": "temporal-golang-pro",
+      "description": "Use when building durable distributed systems with Temporal Go SDK. Covers deterministic workflow rules, mTLS worker configs, and advanced patterns.",
+      "category": "security",
+      "tags": [
+        "temporal",
+        "golang"
+      ],
+      "triggers": [
+        "temporal",
+        "golang",
+        "pro",
+        "building",
+        "durable",
+        "distributed",
+        "go",
+        "sdk",
+        "covers",
+        "deterministic",
+        "rules",
+        "mtls"
+      ],
+      "path": "skills/temporal-golang-pro/SKILL.md"
+    },
    {
      "id": "temporal-python-pro",
      "name": "temporal-python-pro",
--- a/skills/convex/SKILL.md
+++ b/skills/convex/SKILL.md
@@ -0,0 +1,797 @@
+---
+name: convex
+description: "Convex reactive backend expert: schema design, TypeScript functions, real-time subscriptions, auth, file storage, scheduling, and deployment."
+risk: safe
+source: "https://docs.convex.dev"
+---
+
+# Convex
+
+You are an expert in Convex — the open-source, reactive backend platform where queries are TypeScript code. You have deep knowledge of schema design, function authoring (queries, mutations, actions), real-time data subscriptions, authentication, file storage, scheduling, and deployment workflows across React, Next.js, Angular, Vue, Svelte, React Native, and server-side environments.
+
+## When to Use
+
+- Use when building a new project with Convex as the backend
+- Use when adding Convex to an existing React, Next.js, Angular, Vue, Svelte, or React Native app
+- Use when designing schemas for a Convex document-relational database
+- Use when writing or debugging Convex functions (queries, mutations, actions)
+- Use when implementing real-time/reactive data patterns
+- Use when setting up authentication with Convex Auth or third-party providers (Clerk, Auth0, etc.)
+- Use when working with Convex file storage, scheduled functions, or cron jobs
+- Use when deploying or managing Convex projects
+
+## Core Concepts
+
+Convex is a **document-relational** database with a fully managed backend. Key differentiators:
+
+- **Reactive by default**: Queries automatically re-run and push updates to all connected clients when underlying data changes
+- **TypeScript-first**: All backend logic — queries, mutations, actions, schemas — is written in TypeScript
+- **ACID transactions**: Serializable isolation with optimistic concurrency control
+- **No infrastructure to manage**: Serverless, scales automatically, zero config
+- **End-to-end type safety**: Types flow from schema → backend functions → client hooks
+
+### Function Types
+
+| Type            | Purpose                   | Can Read DB    | Can Write DB      | Can Call External APIs | Cached/Reactive |
+| :-------------- | :------------------------ | :------------- | :---------------- | :--------------------- | :-------------- |
+| **Query**       | Read data                 | ✅             | ❌                | ❌                     | ✅              |
+| **Mutation**    | Write data                | ✅             | ✅                | ❌                     | ❌              |
+| **Action**      | Side effects              | via `runQuery` | via `runMutation` | ✅                     | ❌              |
+| **HTTP Action** | Webhooks/custom endpoints | via `runQuery` | via `runMutation` | ✅                     | ❌              |
+
+## Project Setup
+
+### New Project (Next.js)
+
+```bash
+npx create-next-app@latest my-app
+cd my-app && npm install convex
+npx convex dev
+```
+
+### Add to Existing Project
+
+```bash
+npm install convex
+npx convex dev
+```
+
+The `npx convex dev` command:
+
+1. Prompts you to log in (GitHub)
+2. Creates a project and deployment
+3. Generates `convex/` folder for backend functions
+4. Syncs functions to your dev deployment in real-time
+5. Creates `.env.local` with `CONVEX_DEPLOYMENT` and `NEXT_PUBLIC_CONVEX_URL`
+
+### Folder Structure
+
+```
+my-app/
+├── convex/
+│   ├── _generated/        ← Auto-generated (DO NOT EDIT)
+│   │   ├── api.d.ts
+│   │   ├── dataModel.d.ts
+│   │   └── server.d.ts
+│   ├── schema.ts          ← Database schema definition
+│   ├── tasks.ts           ← Query/mutation functions
+│   └── http.ts            ← HTTP actions (optional)
+├── .env.local             ← CONVEX_DEPLOYMENT, NEXT_PUBLIC_CONVEX_URL
+└── convex.json            ← Project config (optional)
+```
+
+## Schema Design
+
+Define your schema in `convex/schema.ts` using the validator library:
+
+```typescript
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  users: defineTable({
+    name: v.string(),
+    email: v.string(),
+    avatarUrl: v.optional(v.string()),
+    tokenIdentifier: v.string(),
+  })
+    .index("by_token", ["tokenIdentifier"])
+    .index("by_email", ["email"]),
+
+  messages: defineTable({
+    authorId: v.id("users"),
+    channelId: v.id("channels"),
+    body: v.string(),
+    attachmentId: v.optional(v.id("_storage")),
+  })
+    .index("by_channel", ["channelId"])
+    .searchIndex("search_body", { searchField: "body" }),
+
+  channels: defineTable({
+    name: v.string(),
+    description: v.optional(v.string()),
+    isPrivate: v.boolean(),
+  }),
+});
+```
+
+### Validator Types
+
+| Validator                         | TypeScript Type       | Notes                                          |
+| :-------------------------------- | :-------------------- | :--------------------------------------------- |
+| `v.string()`                      | `string`              |                                                |
+| `v.number()`                      | `number`              | IEEE 754 float                                 |
+| `v.bigint()`                      | `bigint`              |                                                |
+| `v.boolean()`                     | `boolean`             |                                                |
+| `v.null()`                        | `null`                |                                                |
+| `v.id("tableName")`               | `Id<"tableName">`     | Document reference                             |
+| `v.array(v.string())`             | `string[]`            |                                                |
+| `v.object({...})`                 | `{...}`               | Nested objects                                 |
+| `v.optional(v.string())`          | `string \| undefined` |                                                |
+| `v.union(v.string(), v.number())` | `string \| number`    |                                                |
+| `v.literal("active")`             | `"active"`            | Literal types                                  |
+| `v.bytes()`                       | `ArrayBuffer`         | Binary data                                    |
+| `v.float64()`                     | `number`              | Explicit 64-bit float (used in vector indexes) |
+| `v.any()`                         | `any`                 | Escape hatch                                   |
+
+### Indexes
+
+```typescript
+// Single-field index
+defineTable({ email: v.string() }).index("by_email", ["email"]);
+
+// Compound index (order matters for range queries)
+defineTable({
+  orgId: v.string(),
+  createdAt: v.number(),
+}).index("by_org_and_date", ["orgId", "createdAt"]);
+
+// Full-text search index
+defineTable({ body: v.string(), channelId: v.id("channels") }).searchIndex(
+  "search_body",
+  {
+    searchField: "body",
+    filterFields: ["channelId"],
+  },
+);
+
+// Vector search index (for AI/embeddings)
+defineTable({ embedding: v.array(v.float64()), text: v.string() }).vectorIndex(
+  "by_embedding",
+  {
+    vectorField: "embedding",
+    dimensions: 1536,
+  },
+);
+```
+
+## Writing Functions
+
+### Queries (Read Data)
+
+Queries are reactive — clients automatically get updates when data changes.
+
+````typescript
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+// Simple query — list all tasks
+export const list = query({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.db.query("tasks").collect();
+  },
+});
+
+// Query with arguments and filtering
+export const getByChannel = query({
+  args: { channelId: v.id("channels") },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("messages")
+      .withIndex("by_channel", (q) => q.eq("channelId", args.channelId))
+      .order("desc")
+      .take(50);
+  },
+});
+
+// Query with auth check
+export const getMyProfile = query({
+  args: {},
+  handler: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) return null;
+
+    return await ctx.db
+      .query("users")
+      .withIndex("by_token", (q) =>
+        q.eq("tokenIdentifier", identity.tokenIdentifier),
+      )
+      .unique();
+  },
+});
+
+### Paginated Queries
+
+Use cursor-based pagination for lists or infinite scroll UIs.
+
+```typescript
+import { query } from "./_generated/server";
+import { paginationOptsValidator } from "convex/server";
+
+export const listPaginated = query({
+  args: {
+    paginationOpts: paginationOptsValidator
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("messages")
+      .order("desc")
+      .paginate(args.paginationOpts);
+  },
+});
+```
+
+### Mutations (Write Data)
+
+Mutations run as ACID transactions with serializable isolation.
+
+```typescript
+import { mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+// Insert a document
+export const create = mutation({
+  args: { text: v.string(), isCompleted: v.boolean() },
+  handler: async (ctx, args) => {
+    const taskId = await ctx.db.insert("tasks", {
+      text: args.text,
+      isCompleted: args.isCompleted,
+    });
+    return taskId;
+  },
+});
+
+// Update a document
+export const update = mutation({
+  args: { id: v.id("tasks"), isCompleted: v.boolean() },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, { isCompleted: args.isCompleted });
+  },
+});
+
+// Delete a document
+export const remove = mutation({
+  args: { id: v.id("tasks") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+  },
+});
+
+// Multi-document transaction (automatically atomic)
+export const transferCredits = mutation({
+  args: {
+    fromUserId: v.id("users"),
+    toUserId: v.id("users"),
+    amount: v.number(),
+  },
+  handler: async (ctx, args) => {
+    const fromUser = await ctx.db.get(args.fromUserId);
+    const toUser = await ctx.db.get(args.toUserId);
+    if (!fromUser || !toUser) throw new Error("User not found");
+    if (fromUser.credits < args.amount) throw new Error("Insufficient credits");
+
+    await ctx.db.patch(args.fromUserId, {
+      credits: fromUser.credits - args.amount,
+    });
+    await ctx.db.patch(args.toUserId, {
+      credits: toUser.credits + args.amount,
+    });
+  },
+});
+````
+
+### Actions (External APIs & Side Effects)
+
+Actions can call third-party services but cannot directly access the database — they must use `ctx.runQuery` and `ctx.runMutation`.
+
+```typescript
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+import { api } from "./_generated/api";
+
+export const sendEmail = action({
+  args: { to: v.string(), subject: v.string(), body: v.string() },
+  handler: async (ctx, args) => {
+    // Call external API
+    const response = await fetch("https://api.sendgrid.com/v3/mail/send", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${process.env.SENDGRID_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        personalizations: [{ to: [{ email: args.to }] }],
+        from: { email: "noreply@example.com" },
+        subject: args.subject,
+        content: [{ type: "text/plain", value: args.body }],
+      }),
+    });
+
+    if (!response.ok) throw new Error("Failed to send email");
+
+    // Write result back to database via mutation
+    await ctx.runMutation(api.emails.recordSent, {
+      to: args.to,
+      subject: args.subject,
+      sentAt: Date.now(),
+    });
+  },
+});
+
+// Generate AI embeddings
+export const generateEmbedding = action({
+  args: { text: v.string(), documentId: v.id("documents") },
+  handler: async (ctx, args) => {
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "text-embedding-3-small",
+        input: args.text,
+      }),
+    });
+
+    const { data } = await response.json();
+    await ctx.runMutation(api.documents.saveEmbedding, {
+      documentId: args.documentId,
+      embedding: data[0].embedding,
+    });
+  },
+});
+```
+
+### HTTP Actions (Webhooks)
+
+```typescript
+import { httpRouter } from "convex/server";
+import { httpAction } from "./_generated/server";
+import { api } from "./_generated/api";
+
+const http = httpRouter();
+
+http.route({
+  path: "/webhooks/stripe",
+  method: "POST",
+  handler: httpAction(async (ctx, request) => {
+    const body = await request.text();
+    const signature = request.headers.get("stripe-signature");
+
+    // Verify webhook signature here...
+
+    const event = JSON.parse(body);
+    await ctx.runMutation(api.payments.handleWebhook, { event });
+
+    return new Response("OK", { status: 200 });
+  }),
+});
+
+export default http;
+```
+
+## Client-Side Integration
+
+### React / Next.js
+
+```typescript
+// app/ConvexClientProvider.tsx
+"use client";
+import { ConvexProvider, ConvexReactClient } from "convex/react";
+import { ReactNode } from "react";
+
+const convex = new ConvexReactClient(process.env.NEXT_PUBLIC_CONVEX_URL!);
+
+export function ConvexClientProvider({ children }: { children: ReactNode }) {
+  return <ConvexProvider client={convex}>{children}</ConvexProvider>;
+}
+```
+
+```typescript
+// app/layout.tsx — wrap children
+import { ConvexClientProvider } from "./ConvexClientProvider";
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body>
+        <ConvexClientProvider>{children}</ConvexClientProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+```typescript
+// Component using Convex hooks
+"use client";
+import { useQuery, useMutation } from "convex/react";
+import { api } from "@/convex/_generated/api";
+
+export function TaskList() {
+  // Reactive query — auto-updates when data changes
+  const tasks = useQuery(api.tasks.list);
+  const addTask = useMutation(api.tasks.create);
+  const toggleTask = useMutation(api.tasks.update);
+
+  if (tasks === undefined) return <p>Loading...</p>;
+
+  return (
+    <div>
+      {tasks.map((task) => (
+        <div key={task._id}>
+          <input
+            type="checkbox"
+            checked={task.isCompleted}
+            onChange={() =>
+              toggleTask({ id: task._id, isCompleted: !task.isCompleted })
+            }
+          />
+          {task.text}
+        </div>
+      ))}
+      <button onClick={() => addTask({ text: "New task", isCompleted: false })}>
+        Add Task
+      </button>
+    </div>
+  );
+}
+```
+
+```typescript
+// Component using Paginated Queries
+"use client";
+import { usePaginatedQuery } from "convex/react";
+import { api } from "@/convex/_generated/api";
+
+export function MessageLog() {
+  const { results, status, loadMore } = usePaginatedQuery(
+    api.messages.listPaginated,
+    {}, // args
+    { initialNumItems: 20 }
+  );
+
+  return (
+    <div>
+      {results.map((msg) => (
+        <div key={msg._id}>{msg.body}</div>
+      ))}
+
+      {status === "LoadingFirstPage" && <p>Loading...</p>}
+
+      {status === "CanLoadMore" && (
+        <button onClick={() => loadMore(20)}>Load More</button>
+      )}
+    </div>
+  );
+}
+```
+
+### With Auth (First-Party Convex Auth)
+
+Convex provides a robust, native authentication library (`@convex-dev/auth`) featuring Magic Links, Passwords, and 80+ OAuth providers without needing a third-party service.
+
+```typescript
+// app/ConvexClientProvider.tsx
+"use client";
+import { ConvexAuthProvider } from "@convex-dev/auth/react";
+import { ConvexReactClient } from "convex/react";
+import { ReactNode } from "react";
+
+const convex = new ConvexReactClient(process.env.NEXT_PUBLIC_CONVEX_URL!);
+
+export function ConvexClientProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConvexAuthProvider client={convex}>
+      {children}
+    </ConvexAuthProvider>
+  );
+}
+```
+
+```typescript
+// Client-side sign in
+import { useAuthActions } from "@convex-dev/auth/react";
+
+export function Login() {
+  const { signIn } = useAuthActions();
+  return <button onClick={() => signIn("github")}>Sign in with GitHub</button>;
+}
+```
+
+### With Auth (Third-Party Clerk Example)
+
+If you prefer a hosted third-party solution like Clerk:
+
+```typescript
+// app/ConvexClientProvider.tsx
+"use client";
+import { ConvexProviderWithClerk } from "convex/react-clerk";
+import { ClerkProvider, useAuth } from "@clerk/nextjs";
+import { ConvexReactClient } from "convex/react";
+
+const convex = new ConvexReactClient(process.env.NEXT_PUBLIC_CONVEX_URL!);
+
+export function ConvexClientProvider({ children }: { children: ReactNode }) {
+  return (
+    <ClerkProvider publishableKey={process.env.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY!}>
+      <ConvexProviderWithClerk client={convex} useAuth={useAuth}>
+        {children}
+      </ConvexProviderWithClerk>
+    </ClerkProvider>
+  );
+}
+```
+
+### With Auth (Better Auth Component)
+
+Convex also has a community component (`@convex-dev/better-auth`) that integrates the Better Auth library directly into the Convex backend. This is currently in **early alpha**.
+
+```bash
+npm install better-auth @convex-dev/better-auth
+npx convex env set BETTER_AUTH_SECRET your-secret-here
+npx convex env set SITE_URL http://localhost:3000
+```
+
+Better Auth provides email/password, social logins, two-factor authentication, and session management — all running inside Convex functions rather than an external auth server.
+
+### Angular Integration
+
+Convex does not have an official Angular client library, but Angular apps can use the core `convex` package directly with Angular's Dependency Injection and Signals.
+
+```typescript
+// services/convex.service.ts
+import { Injectable, signal, effect, OnDestroy } from "@angular/core";
+import { ConvexClient } from "convex/browser";
+import { api } from "../../convex/_generated/api";
+import { FunctionReturnType } from "convex/server";
+
+@Injectable({ providedIn: "root" })
+export class ConvexService implements OnDestroy {
+  private client = new ConvexClient(environment.convexUrl);
+
+  // Reactive signal — updates automatically when data changes
+  tasks = signal<FunctionReturnType<typeof api.tasks.list> | undefined>(
+    undefined,
+  );
+
+  constructor() {
+    // Subscribe to a reactive query
+    this.client.onUpdate(api.tasks.list, {}, (result) => {
+      this.tasks.set(result);
+    });
+  }
+
+  async addTask(text: string) {
+    await this.client.mutation(api.tasks.create, {
+      text,
+      isCompleted: false,
+    });
+  }
+
+  ngOnDestroy() {
+    this.client.close();
+  }
+}
+```
+
+```typescript
+// Component usage
+import { Component, inject } from "@angular/core";
+import { ConvexService } from "./services/convex.service";
+
+@Component({
+  selector: "app-task-list",
+  template: `
+    @if (convex.tasks(); as tasks) {
+      @for (task of tasks; track task._id) {
+        <div>{{ task.text }}</div>
+      }
+    } @else {
+      <p>Loading...</p>
+    }
+    <button (click)="convex.addTask('New task')">Add Task</button>
+  `,
+})
+export class TaskListComponent {
+  convex = inject(ConvexService);
+}
+```
+
+> **Note:** The community library `@robmanganelly/ngx-convex` provides a more Angular-native experience with React-like hooks adapted for Angular DI and Signals.
+
+## Scheduling & Cron Jobs
+
+### One-off Scheduled Functions
+
+```typescript
+import { mutation } from "./_generated/server";
+import { api } from "./_generated/api";
+
+export const sendReminder = mutation({
+  args: { userId: v.id("users"), message: v.string(), delayMs: v.number() },
+  handler: async (ctx, args) => {
+    await ctx.scheduler.runAfter(args.delayMs, api.notifications.send, {
+      userId: args.userId,
+      message: args.message,
+    });
+  },
+});
+```
+
+### Cron Jobs
+
+```typescript
+// convex/crons.ts
+import { cronJobs } from "convex/server";
+import { api } from "./_generated/api";
+
+const crons = cronJobs();
+
+crons.interval("clear old logs", { hours: 24 }, api.logs.clearOld);
+
+crons.cron(
+  "weekly digest",
+  "0 9 * * 1", // Every Monday at 9 AM
+  api.emails.sendWeeklyDigest,
+);
+
+export default crons;
+```
+
+## File Storage
+
+```typescript
+// Generate an upload URL (mutation)
+export const generateUploadUrl = mutation({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.storage.generateUploadUrl();
+  },
+});
+
+// Save file reference after upload (mutation)
+export const saveFile = mutation({
+  args: { storageId: v.id("_storage"), name: v.string() },
+  handler: async (ctx, args) => {
+    await ctx.db.insert("files", {
+      storageId: args.storageId,
+      name: args.name,
+    });
+  },
+});
+
+// Get a URL to serve a file (query)
+export const getFileUrl = query({
+  args: { storageId: v.id("_storage") },
+  handler: async (ctx, args) => {
+    return await ctx.storage.getUrl(args.storageId);
+  },
+});
+```
+
+## Environment Variables
+
+```bash
+# Set environment variables for your deployment
+npx convex env set OPENAI_API_KEY sk-...
+npx convex env set SENDGRID_API_KEY SG...
+
+# List current env vars
+npx convex env list
+
+# Remove an env var
+npx convex env unset OPENAI_API_KEY
+```
+
+Access in actions (NOT in queries or mutations):
+
+```typescript
+// Only available in actions
+const apiKey = process.env.OPENAI_API_KEY;
+```
+
+## Deployment & CLI
+
+```bash
+# Development (watches for changes, syncs to dev deployment)
+npx convex dev
+
+# Deploy to production
+npx convex deploy
+
+# Import data
+npx convex import --table tasks data.jsonl
+
+# Export data
+npx convex export --path ./backup
+
+# Open Convex dashboard
+npx convex dashboard
+
+# Run a function from CLI
+npx convex run tasks:list
+
+# View logs
+npx convex logs
+```
+
+## Best Practices
+
+- ✅ Define schemas — adds type safety across your entire stack
+- ✅ Use indexes for queries — avoids full table scans
+- ✅ Use compound indexes with equality filters first, range filter last
+- ✅ Rely on native determinism — `Date.now()` and `Math.random()` are 100% safe to use in queries and mutations because Convex freezes time at the start of every function execution!
+- ✅ Use `v.id("tableName")` for document references instead of plain strings
+- ✅ Use actions for external API calls (never call external APIs from queries or mutations)
+- ✅ Use `ctx.runQuery` / `ctx.runMutation` from actions — never access `ctx.db` directly in actions
+- ✅ Add argument validators to all functions — they enforce runtime type safety
+- ✅ Return `null` when a document isn't found instead of throwing an error unless missing is exceptional
+- ✅ Prefer `withIndex` over `.filter()` for query performance
+
+## Anti-Patterns to Avoid
+
+1. **❌ External API calls in queries/mutations**: Only actions can call external services. Queries and mutations run in the Convex transaction engine.
+2. **❌ Doing slow CPU-bound work in mutations**: Mutations block database commits; offload heavy processing to actions.
+3. **❌ Using `.collect()` on large tables without limits**: Fetches all documents into memory. Use `.take(N)` or `.paginate()`.
+4. **❌ Skipping schema definition**: Without a schema you lose end-to-end type safety, the main Convex advantage.
+5. **❌ Using `.filter()` instead of indexes**: `.filter()` does a full table scan. Define an index and use `.withIndex()`.
+6. **❌ Storing large blobs in documents**: Use Convex file storage (`_storage`) for files; keep documents lean.
+7. **❌ Circular `runQuery`/`runMutation` chains**: Actions calling mutations that schedule actions can create infinite loops.
+
+## Common Pitfalls
+
+- **Problem:** "Query returns `undefined` on first render"
+  **Solution:** This is expected — Convex queries are async. Check for `undefined` before rendering (this means loading, not empty).
+
+- **Problem:** "Mutation throws `Document not found`"
+  **Solution:** Documents may have been deleted between your read and write due to optimistic concurrency. Re-read inside the mutation.
+
+- **Problem:** "`process.env` is undefined in query/mutation"
+  **Solution:** Environment variables are only accessible in **actions** (not queries or mutations) because queries/mutations run in the deterministic transaction engine.
+
+- **Problem:** "Function handler is too slow"
+  **Solution:** Add indexes for your query patterns. Use `withIndex()` instead of `.filter()`. For complex operations, break into smaller mutations.
+
+- **Problem:** "Schema push fails with existing data"
+  **Solution:** Convex validates existing data against new schemas. Either migrate existing documents first, or use `v.optional()` for new fields.
+
+## Limitations
+
+- Queries and mutations cannot call external HTTP APIs (use actions instead)
+- No raw SQL — you work with the Convex query builder API
+- Environment variables only available in actions, not in queries or mutations
+- Document size limit of 1MB
+- Maximum function execution time limits apply
+- No server-side rendering of Convex data without specific SSR patterns (use preloading)
+- Schemas are enforced at write-time; changing schemas requires data migration for existing documents
+
+## Related Skills
+
+- `@firebase` — Alternative BaaS with Firestore (compare: Convex is TypeScript-first with ACID transactions)
+- `@supabase-automation` — Alternative with PostgreSQL backend (compare: Convex is document-relational with built-in reactivity)
+- `@prisma-expert` — ORM for traditional databases (Convex replaces both ORM and database)
+- `@react-patterns` — Frontend patterns that pair well with Convex React hooks
+- `@nextjs-app-router` — Next.js App Router integration patterns
+- `@authentication-oauth` — Auth patterns (Convex supports Clerk, Auth0, Convex Auth)
+- `@stripe` — Payment integration via Convex actions and HTTP webhooks
+
+## Resources
+
+- [Official Docs](https://docs.convex.dev)
+- [Convex Stack (Blog)](https://stack.convex.dev)
+- [GitHub](https://github.com/get-convex/convex-backend)
+- [Discord Community](https://convex.dev/community)
+- [Convex Chef (AI Starter)](https://chef.convex.dev)
--- a/skills/local-legal-seo-audit/SKILL.md
+++ b/skills/local-legal-seo-audit/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: local-legal-seo-audit
-description: When the user wants to audit or improve SEO for a law firm, legal services provider, forensic expert, or other professional services site with local presence. Use when they mention law firm SEO, attorney website, legal services ranking, local legal presence, or forensic services visibility. For general SEO audits, see seo-audit. For technical SEO incidents, see seo-forensic-incident-response.
-risk: low
+description: Audit and improve local SEO for law firms, attorneys, forensic experts and legal/professional services sites with local presence, focusing on GBP, directories, E-E-A-T and practice/location pages.
+risk: safe
 source: original
 metadata:
  version: 1.0.0
@@ -13,6 +13,16 @@ You are an expert in local SEO for legal and professional services. Your goal is

 This skill is scoped to the **specific needs of legal and professional services sites**, where trust signals, local authority, E-E-A-T, and directory presence are the primary ranking levers.

+## When to Use
+
+Use this skill when:
+- You need to audit or improve local SEO for a law firm, attorney, forensic expert, or similar legal/professional services website.
+- The goal is to improve visibility in Google local pack/maps, legal directories, and local organic results for specific practice areas or cities.
+
+Do **not** use this skill when:
+- You need a general SEO health check across any niche (use `seo-audit`).
+- You are investigating a sudden traffic or rankings crash (use `seo-forensic-incident-response`).
+
 ---

 ## Initial Assessment
--- a/skills/seo-forensic-incident-response/SKILL.md
+++ b/skills/seo-forensic-incident-response/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: seo-forensic-incident-response
-description: When the user needs to investigate sudden drops in organic traffic or rankings and perform a forensic SEO incident response. Use when they mention traffic crash, penalty, core update impact, or unexplained ranking loss. For general SEO audits, see seo-audit.
-risk: low
+description: Investigate sudden drops in organic traffic or rankings and run a structured forensic SEO incident response with triage, root-cause analysis and recovery plan.
+risk: safe
 source: original
 metadata:
  version: 1.0.0
@@ -13,6 +13,16 @@ You are an expert in forensic SEO incident response. Your goal is to investigate

 This skill is not a generic SEO audit. It is designed for **incident scenarios**: traffic crashes, suspected penalties, core update impacts, or major technical failures.

+## When to Use
+
+Use this skill when:
+- You need to understand and resolve a sudden, significant drop in organic traffic or rankings.
+- There are signs of a possible penalty, core update impact, major technical regression or other SEO incident.
+
+Do **not** use this skill when:
+- You need a routine SEO health check or prioritization of opportunities (use `seo-audit`).
+- You are focused on long-term local visibility for legal/professional services (use `local-legal-seo-audit`).
+
 ## Initial Incident Triage

 Before deep analysis, clarify the incident context:
--- a/skills_index.json
+++ b/skills_index.json
@@ -2834,6 +2834,15 @@
    "risk": "unknown",
    "source": "community"
  },
+  {
+    "id": "convex",
+    "path": "skills/convex",
+    "category": "uncategorized",
+    "name": "convex",
+    "description": "Convex reactive backend expert: schema design, TypeScript functions, real-time subscriptions, auth, file storage, scheduling, and deployment.",
+    "risk": "safe",
+    "source": "https://docs.convex.dev"
+  },
  {
    "id": "copilot-sdk",
    "path": "skills/copilot-sdk",
@@ -5156,6 +5165,15 @@
    "risk": "unknown",
    "source": "community"
  },
+  {
+    "id": "local-legal-seo-audit",
+    "path": "skills/local-legal-seo-audit",
+    "category": "uncategorized",
+    "name": "local-legal-seo-audit",
+    "description": "Audit and improve local SEO for law firms, attorneys, forensic experts and legal/professional services sites with local presence, focusing on GBP, directories, E-E-A-T and practice/location pages.",
+    "risk": "safe",
+    "source": "original"
+  },
  {
    "id": "logistics-exception-management",
    "path": "skills/logistics-exception-management",
@@ -7001,6 +7019,15 @@
    "risk": "unknown",
    "source": "community"
  },
+  {
+    "id": "seo-forensic-incident-response",
+    "path": "skills/seo-forensic-incident-response",
+    "category": "uncategorized",
+    "name": "seo-forensic-incident-response",
+    "description": "Investigate sudden drops in organic traffic or rankings and run a structured forensic SEO incident response with triage, root-cause analysis and recovery plan.",
+    "risk": "safe",
+    "source": "original"
+  },
  {
    "id": "seo-fundamentals",
    "path": "skills/seo-fundamentals",
@@ -7622,6 +7649,15 @@
    "risk": "unknown",
    "source": "community"
  },
+  {
+    "id": "temporal-golang-pro",
+    "path": "skills/temporal-golang-pro",
+    "category": "uncategorized",
+    "name": "temporal-golang-pro",
+    "description": "Use when building durable distributed systems with Temporal Go SDK. Covers deterministic workflow rules, mTLS worker configs, and advanced patterns.",
+    "risk": "safe",
+    "source": "self"
+  },
  {
    "id": "temporal-python-pro",
    "path": "skills/temporal-python-pro",