opencode-skills-antigravity 1.0.19 → 1.0.21

package/bundled-skills/docs/users/plugins.md

@@ -0,0 +1,157 @@
+# Plugins for Claude Code and Codex
+
+Release `9.0.0` adds first-class plugin distributions for both **Claude Code** and **Codex**.
+
+This page is the canonical explanation of what those plugins are, how they differ from a full library install, and why the repository now ships both a **root plugin** and multiple **bundle plugins**.
+
+## What a plugin is in this repo
+
+In Antigravity Awesome Skills, a plugin is a packaged, installable distribution of skills plus the metadata a host tool needs to expose that distribution through its plugin or marketplace flow.
+
+Plugins are useful when you want:
+
+- a marketplace-style install instead of copying files into `.claude/skills/` or `.codex/skills/`
+- a narrower install surface for a team or role
+- a safer default distribution for plugin ecosystems
+
+Plugins are **not** different content formats. They still ship `SKILL.md` playbooks. The difference is the packaging, install surface, and filtering.
+
+## Full library install vs plugin install
+
+You now have two valid ways to use this repository with Claude Code or Codex.
+
+### Full library install
+
+Use the installer or clone the repository directly when you want the broadest possible coverage:
+
+```bash
+npx antigravity-awesome-skills --claude
+npx antigravity-awesome-skills --codex
+```
+
+Or clone manually into your preferred skills directory.
+
+Choose the full library when you want:
+
+- the largest available catalog
+- repo-only skills that are still being hardened for plugin distribution
+- direct filesystem control over the installed tree
+
+### Plugin install
+
+Use the plugin marketplace or repo-local plugin metadata when you want a curated, installable distribution:
+
+- **Claude Code** uses `.claude-plugin/marketplace.json` and `.claude-plugin/plugin.json`
+- **Codex** uses `.agents/plugins/marketplace.json` and `plugins/antigravity-awesome-skills/.codex-plugin/plugin.json`
+
+Choose the plugin route when you want:
+
+- marketplace-friendly installation
+- a cleaner starter surface
+- plugin-safe filtering by default
+- bundle-specific installs such as `Essentials`, `Security Engineer`, or `Web Wizard`
+
+## What `plugin-safe` means
+
+Not every skill in the repository is immediately suitable for plugin publication.
+
+`plugin-safe` means the published plugin excludes skills that still need hardening, portability cleanup, or explicit setup metadata. In practice, plugin-safe filtering avoids shipping skills that rely on:
+
+- host-specific local paths
+- undeclared manual setup
+- assumptions that are acceptable in the full repository but too brittle for marketplace distribution
+
+This is why the **full library** can be larger than the **plugin-safe** subset. That difference is expected and intentional.
+
+The important rule is:
+
+- the repository remains the source of truth for the complete library
+- plugins publish the hardened subset that is ready for marketplace-style installation
+
+## Root plugin vs bundle plugins
+
+The repository now ships two plugin shapes.
+
+### Root plugin
+
+The root plugin is the broad installable distribution for each host:
+
+- **Claude Code root plugin**: install the plugin-safe Antigravity library through the Claude marketplace entry
+- **Codex root plugin**: expose the plugin-safe Antigravity library through the Codex plugin surface
+
+Use the root plugin when you want the widest plugin-safe install without picking a specialty bundle.
+
+### Bundle plugins
+
+Bundle plugins are smaller, role-based distributions generated from the same repository. Examples include:
+
+- `Essentials`
+- `Security Engineer`
+- `Web Wizard`
+- `Full-Stack Developer`
+
+Use a bundle plugin when you want:
+
+- a lighter starting point
+- a team-specific plugin install
+- a curated subset instead of the broad root plugin
+
+## Claude Code plugin surface
+
+Claude Code uses the repository's root `.claude-plugin` metadata.
+
+Relevant files:
+
+- `.claude-plugin/marketplace.json`
+- `.claude-plugin/plugin.json`
+
+Typical install flow:
+
+```text
+/plugin marketplace add sickn33/antigravity-awesome-skills
+/plugin install antigravity-awesome-skills
+```
+
+Claude Code bundle plugins are also published through the same marketplace metadata, so you can install a focused bundle instead of the root plugin if you prefer.
+
+## Codex plugin surface
+
+Codex uses repo-local plugin metadata that points at the local plugin folders generated by this repository.
+
+Relevant files:
+
+- `.agents/plugins/marketplace.json`
+- `plugins/antigravity-awesome-skills/.codex-plugin/plugin.json`
+
+The Codex root plugin exposes the same plugin-safe library idea as Claude Code, but through Codex's plugin metadata conventions.
+
+Bundle-specific Codex plugins are generated alongside the root plugin so you can install a narrower pack when plugin marketplaces are available in your Codex environment.
+
+## Which path should you choose?
+
+Choose the **full library** if:
+
+- you want the biggest catalog
+- you are comfortable installing directly into skills directories
+- you want repo-only skills that are not yet published as plugins
+
+Choose the **root plugin** if:
+
+- you want the broad installable plugin-safe distribution
+- you prefer marketplace-style installation
+- you want a safer default surface for Claude Code or Codex
+
+Choose a **bundle plugin** if:
+
+- you want a smaller role-based install
+- you are onboarding a team around one domain
+- you want plugin convenience without the breadth of the root plugin
+
+## Related guides
+
+- [Getting Started](getting-started.md)
+- [FAQ](faq.md)
+- [Claude Code skills](claude-code-skills.md)
+- [Codex CLI skills](codex-cli-skills.md)
+- [Bundles](bundles.md)
+- [Usage](usage.md)

package/bundled-skills/docs/users/usage.md

@@ -8,11 +8,13 @@
 
 Great question! Here's what just happened and what to do next:
 
+If you came in through a **Claude Code** or **Codex** plugin instead of a full library install, the mental model is the same: you still invoke individual skills in prompts. The main difference is that plugins ship the plugin-safe subset. See [plugins.md](plugins.md) for the install model.
+
 ### What You Just Did
 
 When you ran `npx antigravity-awesome-skills` or cloned the repository, you:
 
-✅ **Downloaded 1,328+ skill files** to your computer (default: `~/.gemini/antigravity/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)  
+✅ **Downloaded 1,331+ skill files** to your computer (default: `~/.gemini/antigravity/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)  
 ✅ **Made them available** to your AI assistant  
 ❌ **Did NOT enable them all automatically** (they're just sitting there, waiting)
 
@@ -32,7 +34,7 @@ Bundles are **curated groups** of skills organized by role. They help you decide
 
 **Analogy:**
 
-- You installed a toolbox with 1,328+ tools (✅ done)
+- You installed a toolbox with 1,331+ tools (✅ done)
 - Bundles are like **labeled organizer trays** saying: "If you're a carpenter, start with these 10 tools"
 - You can either **pick skills from the tray** or install that tray as a focused marketplace bundle plugin
 
@@ -54,6 +56,14 @@ When you see the [Web Wizard bundle](bundles.md#-the-web-wizard-pack), it lists:
 
 These are **recommendations** for which skills a web developer should try first. If you have the full library installed, you just need to **use them in your prompts**. If you prefer a narrower install surface, you can install the matching bundle plugin in Claude Code or Codex where plugin marketplaces are available.
 
+The key distinction is:
+
+- **full library install** = broadest catalog
+- **root plugin** = broad plugin-safe distribution
+- **bundle plugin** = curated plugin-safe subset
+
+See [plugins.md](plugins.md) for the canonical explanation.
+
 If you want only one bundle active at a time in Antigravity, use the activation scripts instead of trying to invoke the bundle name directly:
 
 ```bash
@@ -202,7 +212,7 @@ Let's actually use a skill right now. Follow these steps:
 
 ## Step 5: Picking Your First Skills (Practical Advice)
 
-Don't try to use all 1,328+ skills at once. Here's a sensible approach:
+Don't try to use all 1,331+ skills at once. Here's a sensible approach:
 
 If you want a tool-specific starting point before choosing skills, use:
 
@@ -333,7 +343,7 @@ Usually no, but if your AI doesn't recognize a skill:
 
 ### "Can I load all skills into the model at once?"
 
-No. Even though you have 1,328+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
+No. Even though you have 1,331+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
 
 The intended pattern is:
 

package/bundled-skills/docs/users/visual-guide.md

@@ -34,7 +34,7 @@ antigravity-awesome-skills/
 ├── 📄 CONTRIBUTING.md                  ← Contributor workflow
 ├── 📄 CATALOG.md                       ← Full generated catalog
 │
-├── 📁 skills/                          ← 1,328+ skills live here
+├── 📁 skills/                          ← 1,331+ skills live here
 │   │
 │   ├── 📁 brainstorming/
 │   │   └── 📄 SKILL.md                 ← Skill definition
@@ -47,7 +47,7 @@ antigravity-awesome-skills/
 │   │   └── 📁 2d-games/
 │   │       └── 📄 SKILL.md             ← Nested skills also supported
 │   │
-│   └── ... (1,328+ total)
+│   └── ... (1,331+ total)
 │
 ├── 📁 apps/
 │   └── 📁 web-app/                     ← Interactive browser
@@ -100,7 +100,7 @@ antigravity-awesome-skills/
 
 ```
                     ┌─────────────────────────┐
-                    │  1,328+ SKILLS          │
+                    │  1,331+ SKILLS          │
                     └────────────┬────────────┘
                                  │
         ┌────────────────────────┼────────────────────────┐
@@ -201,7 +201,7 @@ If you want a workspace-style manual install instead, cloning into `.agent/skill
 │   ├── 📁 brainstorming/                 │
 │   ├── 📁 stripe-integration/            │
 │   ├── 📁 react-best-practices/          │
-│   └── ... (1,328+ total)                │
+│   └── ... (1,331+ total)                │
 └─────────────────────────────────────────┘
 ```
 

package/bundled-skills/phase-gated-debugging/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: phase-gated-debugging
+description: "Use when debugging any bug. Enforces a 5-phase protocol where code edits are blocked until root cause is confirmed. Prevents premature fix attempts."
+risk: safe
+source: community
+date_added: "2026-03-28"
+---
+
+# Phase-Gated Debugging
+
+## Overview
+
+AI coding agents see an error and immediately edit code. They guess at fixes, get it wrong, and spiral. This skill enforces a strict 5-phase protocol where you CANNOT edit source code until the root cause is identified and confirmed.
+
+Based on [claude-debug](https://github.com/krabat-l/claude-debug) (full plugin with PreToolUse hook enforcement).
+
+## When to Use
+
+Use this skill when:
+
+- a bug keeps getting "fixed" without resolving the underlying issue
+- you need to slow an agent down and force disciplined debugging before code edits
+- the failure is intermittent, a regression, performance-related, or otherwise hard to isolate
+- you want an explicit user confirmation checkpoint before any fix is applied
+
+## The Protocol
+
+### Phase 1: REPRODUCE
+Run the failing command/test. Capture the exact error. Run 2-3 times for consistency.
+- Do NOT read source code
+- Do NOT hypothesize
+- Do NOT edit any files
+
+### Phase 2: ISOLATE
+Read code. Add diagnostic logging marked `// DEBUG`. Re-run with diagnostics. Binary search to narrow down.
+- Only `// DEBUG` marked logging is allowed
+- Do NOT fix the bug even if you see it
+
+### Phase 3: ROOT CAUSE
+Analyze WHY at the isolated location. Use "5 Whys" technique. Remove debug logging.
+
+State: "This is my root cause analysis: [explanation]. Do you agree, or should I investigate further?"
+
+**WAIT for user confirmation. Do NOT proceed without it.**
+
+### Phase 4: FIX
+Remove all `// DEBUG` lines. Apply minimal change addressing confirmed root cause.
+- Only edit files related to root cause
+- Do NOT refactor unrelated code
+
+### Phase 5: VERIFY
+Run original failing test — must pass. Run related tests. For intermittent bugs, run 5+ times.
+If verification fails: root cause was wrong, go back to Phase 2.
+
+## Bug-Type Strategies
+
+| Type | Technique |
+|------|-----------|
+| Crash/Panic | Stack trace backward — trace the bad value to its source |
+| Wrong Output | Binary search — log midpoint, halve search space each iteration |
+| Intermittent | Compare passing vs failing run logs — find ordering divergence |
+| Regression | `git bisect` — find the offending commit |
+| Performance | Timing at stage boundaries — find the bottleneck |
+
+## Key Rules
+
+1. NEVER edit source code in phases 1-3 (except `// DEBUG` in phase 2)
+2. NEVER proceed past phase 3 without user confirmation
+3. ALWAYS reproduce before investigating
+4. ALWAYS verify after fixing

package/bundled-skills/playwright-skill/SKILL.md

@@ -4,6 +4,11 @@ description: "IMPORTANT - Path Resolution: This skill can be installed in differ
 risk: unknown
 source: community
 date_added: "2026-02-27"
+plugin:
+  setup:
+    type: manual
+    summary: "Run `npm run setup` in the skill directory before first use to install Playwright and Chromium."
+    docs: "SKILL.md"
 ---
 
 **IMPORTANT - Path Resolution:**
@@ -11,9 +16,9 @@ This skill can be installed in different locations (plugin system, manual instal
 
 Common installation paths:
 
-- Plugin system: `~/.claude/plugins/marketplaces/playwright-skill/skills/playwright-skill`
-- Manual global: `~/.claude/skills/playwright-skill`
-- Project-specific: `<project>/.claude/skills/playwright-skill`
+- Plugin system: `<plugin-root>/skills/playwright-skill`
+- Manual global: `<agent-home>/skills/playwright-skill`
+- Project-specific: `<project>/.agent/skills/playwright-skill`
 
 # Playwright Browser Automation
 

package/bundled-skills/saas-multi-tenant/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: saas-multi-tenant
+description: "Design and implement multi-tenant SaaS architectures with row-level security, tenant-scoped queries, shared-schema isolation, and safe cross-tenant admin patterns in PostgreSQL and TypeScript."
+risk: safe
+source: community
+date_added: "2026-03-28"
+tags: [multi-tenancy, saas, row-level-security, postgresql, tenant-isolation]
+tools: [claude, cursor, gemini]
+---
+
+# SaaS Multi-Tenant Architecture
+
+## When to Use This Skill
+
+- The user is building a SaaS application where multiple customers share the same database
+- The user asks about tenant isolation, row-level security, or data leakage prevention
+- The user needs to scope every database query to a specific tenant without manual WHERE clauses
+- The user asks about shared-schema vs schema-per-tenant vs database-per-tenant tradeoffs
+- The user is implementing admin endpoints that must access data across tenants
+- The user needs to add `tenant_id` columns to an existing single-tenant application
+- The user asks about PostgreSQL RLS policies for tenant isolation
+- The user is building tenant-aware middleware in Express, Fastify, or Next.js API routes
+
+Do NOT use this skill when:
+- The user is building a single-user application with no shared infrastructure
+- The user asks about authentication only without tenant scoping (use an auth skill instead)
+- The user needs general database schema design without multi-tenancy requirements
+
+## Core Workflow
+
+1. Determine the tenancy model. Ask the user about their scale expectations and isolation requirements. For most SaaS apps under 1000 tenants, shared-schema with a `tenant_id` column on every table is the correct default. Schema-per-tenant adds operational overhead (migrations run N times). Database-per-tenant is only justified when tenants have regulatory data residency requirements.
+
+2. Add `tenant_id` to every tenant-scoped table. The column must be `NOT NULL`, type `UUID` or `TEXT`, and included in every composite index. Never allow a tenant-scoped table to exist without this column — a missing `tenant_id` is a data leak waiting to happen.
+
+3. Set up PostgreSQL Row-Level Security (RLS). Create a policy on each tenant-scoped table that filters rows by `current_setting('app.current_tenant_id')`. This acts as a database-level safety net — even if application code forgets a WHERE clause, RLS blocks cross-tenant reads.
+
+4. Build tenant-aware middleware. At the start of every request, extract the `tenant_id` from the authenticated session or JWT claims. Set it on the database connection using `SET LOCAL app.current_tenant_id = '...'` inside a transaction. Every subsequent query in that request inherits the tenant scope automatically.
+
+5. Scope all ORM queries by tenant. If using Prisma, apply a global middleware that injects `where: { tenantId }` into every `findMany`, `findFirst`, `update`, and `delete` call. If using Drizzle, create a base query builder that includes the tenant filter. Never rely on developers remembering to add the filter manually.
+
+6. Handle tenant-aware migrations. Every new table migration must include `tenant_id` as a column. Write a linting rule or CI check that rejects any migration creating a table without `tenant_id` unless the table is explicitly marked as global (e.g., `plans`, `feature_flags`).
+
+7. Build cross-tenant admin routes separately. Admin endpoints that aggregate data across tenants must bypass RLS explicitly using `SET LOCAL role = 'admin_bypass'` or a dedicated database role. These routes must be protected by a separate admin authentication flow — never reuse tenant user sessions for admin access.
+
+8. Implement tenant provisioning. When a new customer signs up, create their tenant record, seed default data (roles, settings, onboarding state), and assign the founding user. Wrap this in a database transaction so partial provisioning never leaves orphan records.
+
+## Examples
+
+### Example 1: PostgreSQL RLS Policy for Tenant Isolation
+
+```sql
+-- Enable RLS on the table
+ALTER TABLE projects ENABLE ROW LEVEL SECURITY;
+ALTER TABLE projects FORCE ROW LEVEL SECURITY;
+
+-- Policy: users can only see rows where tenant_id matches the session variable
+CREATE POLICY tenant_isolation ON projects
+  USING (tenant_id = current_setting('app.current_tenant_id')::uuid);
+
+-- Policy for INSERT: new rows must match the current tenant
+CREATE POLICY tenant_insert ON projects
+  FOR INSERT
+  WITH CHECK (tenant_id = current_setting('app.current_tenant_id')::uuid);
+```
+
+### Example 2: Express Middleware That Sets Tenant Context per Request
+
+```typescript
+import { Pool } from "pg";
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+async function tenantMiddleware(req, res, next) {
+  const tenantId = req.auth?.tenantId; // extracted from JWT during auth
+  if (!tenantId) return res.status(403).json({ error: "No tenant context" });
+
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+    // Use set_config — SET LOCAL does not accept bind placeholders ($1)
+    await client.query("SELECT set_config('app.current_tenant_id', $1, true)", [tenantId]);
+    req.db = client;
+    req.tenantId = tenantId;
+
+    // Cleanup on response finish — guarantees release even if handler skips next()
+    res.on("finish", async () => {
+      try { await client.query("COMMIT"); } catch { await client.query("ROLLBACK"); }
+      client.release();
+    });
+
+    next();
+  } catch (err) {
+    await client.query("ROLLBACK").catch(() => {});
+    client.release();
+    next(err);
+  }
+}
+```
+
+### Example 3: Prisma Middleware for Automatic Tenant Scoping
+
+```typescript
+import { PrismaClient } from "@prisma/client";
+
+// Tables that do NOT have tenant_id (global tables)
+const GLOBAL_TABLES = new Set(["Plan", "FeatureFlag", "SystemConfig"]);
+
+function createTenantPrisma(tenantId: string): PrismaClient {
+  const prisma = new PrismaClient();
+
+  prisma.$use(async (params, next) => {
+    if (GLOBAL_TABLES.has(params.model ?? "")) return next(params);
+
+    // Initialize args.where — Prisma passes undefined args for calls like findMany()
+    params.args = params.args ?? {};
+    params.args.where = params.args.where ?? {};
+
+    // Inject tenant filter on reads (skip findUnique — it only accepts unique-field selectors)
+    if (["findMany", "findFirst", "count", "aggregate"].includes(params.action)) {
+      params.args.where = { ...params.args.where, tenantId };
+    }
+
+    // Inject tenant_id on creates
+    if (["create", "createMany"].includes(params.action)) {
+      params.args.data = params.args.data ?? {};
+      if (params.action === "createMany") {
+        params.args.data = params.args.data.map((d: any) => ({ ...d, tenantId }));
+      } else {
+        params.args.data = { ...params.args.data, tenantId };
+      }
+    }
+
+    // Scope updates and deletes
+    if (["update", "updateMany", "delete", "deleteMany"].includes(params.action)) {
+      params.args.where = { ...params.args.where, tenantId };
+    }
+
+    return next(params);
+  });
+
+  return prisma;
+}
+```
+
+## Never Do This
+
+1. **Never query a tenant-scoped table without a `tenant_id` filter.** Even if your ORM middleware handles it, raw SQL queries bypass middleware entirely. Every raw query must include `WHERE tenant_id = $1` or rely on RLS. A single unscoped `SELECT * FROM invoices` leaks every customer's billing data.
+
+2. **Never store `tenant_id` only in the application session without enforcing it at the database level.** Application-layer filtering is a suggestion. RLS is enforcement. If a bug in your middleware skips the tenant filter, only RLS prevents the data leak. Run both layers.
+
+3. **Never use auto-incrementing integer IDs for tenant-scoped resources.** Sequential IDs (`invoice #1042`) let attackers enumerate other tenants' resources by incrementing the ID. Use UUIDs for all tenant-scoped primary keys. Reserve integer IDs for internal-only tables.
+
+4. **Never let tenant users access admin aggregation endpoints.** A route like `GET /admin/metrics` that queries across all tenants must never be reachable with a regular tenant JWT. Use a separate authentication mechanism (API key, admin role claim with a different issuer) for cross-tenant routes.
+
+5. **Never run migrations with RLS enabled on the migration connection.** The migration user needs to create tables, add columns, and modify policies. If RLS is active on the migration connection, `ALTER TABLE` commands may silently fail or affect only the "current tenant's" view. Use a dedicated superuser or `bypassrls` role for migrations.
+
+6. **Never share connection pools across tenants when using `SET LOCAL`.** If you use `SET LOCAL app.current_tenant_id` inside a transaction, that setting is scoped to the transaction. But if a previous request's transaction was not properly committed or rolled back, the connection returns to the pool with stale tenant context. Always `RESET app.current_tenant_id` in the cleanup path.
+
+## Edge Cases
+
+1. **Tenant deletion and data retention.** When a tenant cancels their subscription, you cannot simply `DELETE FROM tenants WHERE id = $1`. Foreign key cascades may time out on large datasets. Instead, soft-delete the tenant (set `deleted_at`), revoke all user sessions, then run a background job that deletes tenant data in batches over hours or days.
+
+2. **Tenant data export for GDPR/compliance.** When a tenant requests a full data export, you need to query every tenant-scoped table for that `tenant_id` and package it. Build a registry of all tenant-scoped tables (parse your migration files or maintain a manifest) so the export job doesn't miss tables added after the export feature was built.
+
+3. **Shared resources between tenants.** Some features require shared state — e.g., a marketplace where Tenant A's products are visible to Tenant B's users. These tables need a different RLS policy: read access is public (no tenant filter), but write access is still scoped to the owning tenant. Model these as `owner_tenant_id` instead of `tenant_id`.
+
+4. **Tenant-aware background jobs.** When a cron job or queue worker processes tasks, there is no HTTP request to extract `tenant_id` from. The job payload must include `tenant_id`, and the worker must set the database session variable before processing. Never run background jobs without tenant context — they will either fail on RLS or bypass it entirely.
+
+5. **Connection pool exhaustion with schema-per-tenant.** If you use one PostgreSQL schema per tenant and each schema requires its own connection pool, 500 tenants means 500 pools. This exhausts `max_connections` fast. Use a connection pooler like PgBouncer in transaction mode, or switch to shared-schema before hitting this wall.
+
+## Best Practices
+
+1. **Create a `tenants` table as the single source of truth.** Every `tenant_id` foreign key in every table points back to `tenants.id`. Include columns for `name`, `slug` (for subdomain routing), `plan_id`, `created_at`, and `deleted_at`. This table is the root of your entire data model.
+
+2. **Index `tenant_id` as the first column in every composite index.** PostgreSQL uses leftmost prefix matching for composite indexes. An index on `(tenant_id, created_at)` serves both "all items for tenant X" and "items for tenant X sorted by date." An index on `(created_at, tenant_id)` only helps date-range queries across all tenants.
+
+3. **Use subdomains or path prefixes for tenant routing.** `acme.yourapp.com` or `yourapp.com/org/acme` — both work. Map the subdomain or path to a `tenant_id` lookup at the edge (middleware or reverse proxy). This lookup should be cached (Redis or in-memory with 60s TTL) since it runs on every single request.
+
+4. **Separate tenant-scoped tables from global tables explicitly.** Maintain a list (code constant or database table) of which tables are global (no `tenant_id`) and which are tenant-scoped. Use this list in your ORM middleware, your migration linter, and your data export job. If a table isn't in either list, the CI check should fail.
+
+5. **Test with at least 3 tenants in your seed data.** A single tenant in development hides every multi-tenancy bug. Two tenants hides bugs where the first tenant's data leaks to the second but not vice versa. Three tenants catches ordering and filtering bugs that only appear with multiple peers.
+
+6. **Rate-limit and quota per tenant, not globally.** A global rate limit of 1000 requests/minute means one noisy tenant can exhaust the quota for everyone. Implement per-tenant rate limiting using a Redis key pattern like `ratelimit:{tenant_id}:{endpoint}` with a sliding window counter.

package/bundled-skills/threejs-animation/SKILL.md

@@ -12,22 +12,23 @@ source: community
 ```javascript
 import * as THREE from "three";
 
-// Simple procedural animation
-const clock = new THREE.Clock();
+// Simple procedural animation with Timer (recommended in r183)
+const timer = new THREE.Timer();
 
-function animate() {
-  const delta = clock.getDelta();
-  const elapsed = clock.getElapsedTime();
+renderer.setAnimationLoop(() => {
+  timer.update();
+  const delta = timer.getDelta();
+  const elapsed = timer.getElapsed();
 
   mesh.rotation.y += delta;
   mesh.position.y = Math.sin(elapsed) * 0.5;
 
-  requestAnimationFrame(animate);
   renderer.render(scene, camera);
-}
-animate();
+});
 ```
 
+**Note:** `THREE.Timer` is recommended over `THREE.Clock` as of r183. Timer pauses when the page is hidden and has a cleaner API. `THREE.Clock` still works but is considered legacy.
+
 ## Animation System Overview
 
 Three.js animation system has three main components:
@@ -118,6 +119,10 @@ track.setInterpolation(THREE.InterpolateSmooth); // Cubic spline
 track.setInterpolation(THREE.InterpolateDiscrete); // Step function
 ```
 
+### BezierInterpolant (r183)
+
+Three.js r183 adds `THREE.BezierInterpolant` for bezier curve interpolation in keyframe tracks, enabling smoother animation curves with tangent control.
+
 ## AnimationMixer
 
 Plays animations on an object and its descendants.

package/bundled-skills/threejs-fundamentals/SKILL.md

@@ -416,7 +416,24 @@ function dispose() {
 }
 ```
 
-### Clock for Animation
+### Timer and Clock for Animation
+
+**Timer (recommended in r183)** - pauses when tab is hidden, cleaner API:
+
+```javascript
+const timer = new THREE.Timer();
+
+renderer.setAnimationLoop(() => {
+  timer.update();
+  const delta = timer.getDelta();
+  const elapsed = timer.getElapsed();
+
+  mesh.rotation.y += delta * 0.5;
+  renderer.render(scene, camera);
+});
+```
+
+**Clock (legacy, still works):**
 
 ```javascript
 const clock = new THREE.Clock();
@@ -432,6 +449,17 @@ function animate() {
 }
 ```
 
+### Animation Loop
+
+Prefer `renderer.setAnimationLoop()` over manual `requestAnimationFrame`. It handles WebXR compatibility and is the standard Three.js pattern:
+
+```javascript
+renderer.setAnimationLoop(() => {
+  controls.update();
+  renderer.render(scene, camera);
+});
+```
+
 ### Responsive Canvas
 
 ```javascript
@@ -483,6 +511,21 @@ lod.addLevel(lowDetailMesh, 100);
 scene.add(lod);
 ```
 
+## WebGPU Renderer (r183)
+
+Three.js includes an experimental WebGPU renderer as an alternative to WebGL:
+
+```javascript
+import { WebGPURenderer } from "three/addons/renderers/webgpu/WebGPURenderer.js";
+
+const renderer = new WebGPURenderer({ antialias: true });
+await renderer.init();
+renderer.setSize(window.innerWidth, window.innerHeight);
+document.body.appendChild(renderer.domElement);
+```
+
+WebGPU uses TSL (Three.js Shading Language) instead of GLSL. The WebGL renderer remains the default and is fully supported.
+
 ## See Also
 
 - `threejs-geometry` - Geometry creation and manipulation

package/bundled-skills/threejs-geometry/SKILL.md

@@ -543,6 +543,36 @@ new THREE.SphereGeometry(1, 16, 16); // Performance mode
 geometry.dispose();
 ```
 
+## BatchedMesh (r183)
+
+`BatchedMesh` is a higher-level alternative to `InstancedMesh` that supports multiple geometries in a single draw call. As of r183, it supports **per-instance opacity** and **per-instance wireframe**.
+
+```javascript
+const batchedMesh = new THREE.BatchedMesh(maxGeometryCount, maxVertexCount, maxIndexCount);
+batchedMesh.sortObjects = true; // Enable depth sorting for transparency
+
+// Add different geometries
+const boxId = batchedMesh.addGeometry(new THREE.BoxGeometry(1, 1, 1));
+const sphereId = batchedMesh.addGeometry(new THREE.SphereGeometry(0.5, 16, 16));
+
+// Add instances of those geometries
+const instance1 = batchedMesh.addInstance(boxId);
+const instance2 = batchedMesh.addInstance(sphereId);
+
+// Set transforms
+const matrix = new THREE.Matrix4();
+matrix.setPosition(2, 0, 0);
+batchedMesh.setMatrixAt(instance1, matrix);
+
+// Per-instance opacity (r183)
+batchedMesh.setOpacityAt(instance1, 0.5);
+
+// Per-instance visibility
+batchedMesh.setVisibleAt(instance2, false);
+
+scene.add(batchedMesh);
+```
+
 ## See Also
 
 - `threejs-fundamentals` - Scene setup and Object3D