@frontmcp/skills 1.0.4 → 1.1.0

package/catalog/frontmcp-setup/examples/setup-project/vercel-serverless-server.md

@@ -19,8 +19,7 @@ Configure a FrontMCP server for Vercel deployment with Vercel KV storage and mod
 
 ```typescript
 // src/tools/lookup-user.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'lookup_user',
@@ -37,6 +36,7 @@ export default class LookupUserTool extends ToolContext {
 ```typescript
 // src/apps/users.app.ts
 import { App } from '@frontmcp/sdk';
+
 import LookupUserTool from '../tools/lookup-user.tool';
 
 @App({
@@ -49,7 +49,9 @@ export class UsersApp {}
 ```typescript
 // src/main.ts
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
+
 import { UsersApp } from './apps/users.app';
 
 @FrontMcp({

package/catalog/frontmcp-setup/examples/setup-redis/hybrid-vercel-kv-with-pubsub.md

@@ -2,18 +2,20 @@
 name: hybrid-vercel-kv-with-pubsub
 reference: setup-redis
 level: advanced
-description: 'Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions.'
+description: 'Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions in distributed multi-instance deployments.'
 tags: [setup, vercel-kv, redis, vercel, session, hybrid]
 features:
   - 'Vercel KV handles sessions (`redis` config) while a real Redis handles pub/sub (`pubsub` config)'
-  - 'Vercel KV does not support pub/sub operations, so a separate Redis instance is required'
-  - 'Resources with `subscribe: true` rely on the `pubsub` config for real-time notifications'
+  - 'Vercel KV does not support pub/sub operations, so a separate Redis instance is required for distributed setups'
+  - 'Resource subscriptions across multiple server instances rely on the `pubsub` config for cross-instance notifications (single-instance servers use in-memory subscriptions automatically)'
   - "The `pubsub` field accepts `provider: 'redis'` only (no Vercel KV support)"
 ---
 
 # Hybrid Vercel KV with Redis Pub/Sub
 
-Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions.
+Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions in distributed multi-instance deployments.
+
+> **Note:** Single-server deployments (stdio, binary, or single-instance HTTP) do not need pub/sub — resource subscriptions work in-memory out of the box.
 
 ## Code
 
@@ -50,7 +52,6 @@ import { Resource, ResourceContext } from '@frontmcp/sdk';
   uri: 'metrics://live',
   name: 'Live Metrics',
   mimeType: 'application/json',
-  subscribe: true,
 })
 export default class LiveMetricsResource extends ResourceContext {
   async read() {
@@ -69,8 +70,8 @@ REDIS_PUBSUB_PASSWORD=secret
 ## What This Demonstrates
 
 - Vercel KV handles sessions (`redis` config) while a real Redis handles pub/sub (`pubsub` config)
-- Vercel KV does not support pub/sub operations, so a separate Redis instance is required
-- Resources with `subscribe: true` rely on the `pubsub` config for real-time notifications
+- Vercel KV does not support pub/sub operations, so a separate Redis instance is required for distributed setups
+- Resource subscriptions across multiple server instances rely on the `pubsub` config for cross-instance notifications (single-instance servers use in-memory subscriptions automatically)
 - The `pubsub` field accepts `provider: 'redis'` only (no Vercel KV support)
 
 ## Related

package/catalog/frontmcp-setup/references/setup-project.md

@@ -141,6 +141,7 @@ The `@FrontMcp` decorator accepts a `FrontMcpMetadata` object with these fields:
 
 ```typescript
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
@@ -180,6 +181,7 @@ export default class Server {}
 
 ```typescript
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
@@ -225,8 +227,7 @@ export default class Server {}
 Create `src/tools/add.tool.ts`:
 
 ```typescript
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'add',
@@ -249,6 +250,7 @@ Create `src/apps/calc.app.ts`:
 
 ```typescript
 import { App } from '@frontmcp/sdk';
+
 import AddTool from '../tools/add.tool';
 
 @App({
@@ -276,7 +278,9 @@ Update `src/main.ts`:
 
 ```typescript
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
+
 import { CalcApp } from './apps/calc.app';
 
 @FrontMcp({
@@ -292,24 +296,21 @@ Resources, Prompts, and Skills follow the same decorator pattern:
 
 ```typescript
 // Resource - returns MCP ReadResourceResult
-import { Resource, ResourceContext } from '@frontmcp/sdk';
+// Prompt - returns MCP GetPromptResult
+
+// Skill - compound capability with tools + instructions
+import { Prompt, PromptContext, Resource, ResourceContext, Skill, SkillContext } from '@frontmcp/sdk';
 
 @Resource({ uri: 'config://app', name: 'App Config', mimeType: 'application/json' })
 export default class AppConfigResource extends ResourceContext {
   /* ... */
 }
 
-// Prompt - returns MCP GetPromptResult
-import { Prompt, PromptContext } from '@frontmcp/sdk';
-
 @Prompt({ name: 'summarize', description: 'Summarize a document' })
 export default class SummarizePrompt extends PromptContext {
   /* ... */
 }
 
-// Skill - compound capability with tools + instructions
-import { Skill, SkillContext } from '@frontmcp/sdk';
-
 @Skill({ name: 'data-analysis', description: 'Analyze datasets' })
 export default class DataAnalysisSkill extends SkillContext {
   /* ... */

package/catalog/frontmcp-setup/references/setup-redis.md

@@ -15,15 +15,16 @@ description: Provision and configure Redis or Vercel KV for session storage and
 
 ### Recommended
 
-- Resource subscriptions with `subscribe: true` are enabled and need pub/sub
+- Resource subscriptions with `subscribe: true` across **multiple server instances** (distributed pub/sub)
 - Auth sessions or elicitation state must persist across server restarts
 - Distributed rate limiting is configured in the throttle guard
 
 ### Skip When
 
-- Running a single-instance stdio-only server for local development -- use `setup-sqlite` or in-memory stores
+- Running a single-instance stdio-only server for local development -- use `setup-sqlite` or in-memory stores (resource subscriptions work in-memory without Redis)
 - Only need to configure session TTL and key prefix on an already-provisioned Redis -- use `configure-session`
 - Deploying a read-only MCP server with no sessions, subscriptions, or stateful tools
+- Using resource subscriptions on a single server instance -- subscriptions work in-memory out of the box
 
 > **Decision:** Use this skill to provision and connect Redis (Docker, existing instance, or Vercel KV); use `configure-session` to tune session-specific options after Redis is available.
 
@@ -217,9 +218,11 @@ const sessionStore = createSessionStoreSync({
 });
 ```
 
-## Step 4 -- Pub/Sub for Resource Subscriptions
+## Step 4 -- Pub/Sub for Resource Subscriptions (Multi-Instance Only)
 
-If your server exposes resources with `subscribe: true`, you need pub/sub. Pub/sub requires a real Redis instance -- Vercel KV does not support pub/sub operations.
+> **Single-server note:** If you run a single server instance (stdio, binary, or single-instance HTTP), resource subscriptions work in-memory without any Redis or pub/sub configuration. Skip this step for local development and single-server deployments.
+
+For **distributed multi-instance** deployments where subscription state must be shared across server instances, you need pub/sub. Pub/sub requires a real Redis instance -- Vercel KV does not support pub/sub operations.
 
 For a hybrid setup (Vercel KV for sessions, Redis for pub/sub):
 
@@ -318,13 +321,13 @@ You should see session keys like `mcp:session:<session-id>`.
 
 ## Common Patterns
 
-| Pattern                | Correct                                                                                    | Incorrect                                               | Why                                                                                                                                         |
-| ---------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
-| Redis provider field   | `redis: { provider: 'redis', host: '...', port: 6379 }`                                    | `redis: { host: '...', port: 6379 }` without `provider` | Both forms are type-safe (the SDK's `RedisOptions` union accepts both shapes), but explicit `provider: 'redis'` improves clarity and intent |
-| Environment variables  | `host: process.env['REDIS_HOST'] ?? 'localhost'`                                           | Hardcoding `host: 'redis.internal'` in source           | Hardcoded values break across environments (dev, staging, prod); always read from env with a sensible fallback                              |
-| Vercel KV credentials  | Let Vercel auto-inject `KV_REST_API_URL` and `KV_REST_API_TOKEN`                           | Manually setting KV tokens in the `redis` config object | Auto-injection is safer and ensures tokens rotate correctly; manual values risk stale or committed secrets                                  |
-| Docker persistence     | `command: redis-server --appendonly yes` in docker-compose                                 | Running Redis without `--appendonly` in development     | Without AOF persistence, data is lost on container restart; `--appendonly yes` preserves data across restarts                               |
-| Pub/sub with Vercel KV | Separate `pubsub: { provider: 'redis', ... }` alongside `redis: { provider: 'vercel-kv' }` | Expecting Vercel KV to handle pub/sub                   | Vercel KV does not support pub/sub; a real Redis instance is required for resource subscriptions                                            |
+| Pattern                | Correct                                                                                    | Incorrect                                               | Why                                                                                                                                                                                        |
+| ---------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Redis provider field   | `redis: { provider: 'redis', host: '...', port: 6379 }`                                    | `redis: { host: '...', port: 6379 }` without `provider` | Both forms are type-safe (the SDK's `RedisOptions` union accepts both shapes), but explicit `provider: 'redis'` improves clarity and intent                                                |
+| Environment variables  | `host: process.env['REDIS_HOST'] ?? 'localhost'`                                           | Hardcoding `host: 'redis.internal'` in source           | Hardcoded values break across environments (dev, staging, prod); always read from env with a sensible fallback                                                                             |
+| Vercel KV credentials  | Let Vercel auto-inject `KV_REST_API_URL` and `KV_REST_API_TOKEN`                           | Manually setting KV tokens in the `redis` config object | Auto-injection is safer and ensures tokens rotate correctly; manual values risk stale or committed secrets                                                                                 |
+| Docker persistence     | `command: redis-server --appendonly yes` in docker-compose                                 | Running Redis without `--appendonly` in development     | Without AOF persistence, data is lost on container restart; `--appendonly yes` preserves data across restarts                                                                              |
+| Pub/sub with Vercel KV | Separate `pubsub: { provider: 'redis', ... }` alongside `redis: { provider: 'vercel-kv' }` | Expecting Vercel KV to handle pub/sub                   | Vercel KV does not support pub/sub; a real Redis instance is required for distributed resource subscriptions (single-instance servers use in-memory subscriptions and do not need pub/sub) |
 
 ## Verification Checklist
 
@@ -359,11 +362,11 @@ You should see session keys like `mcp:session:<session-id>`.
 
 ## Examples
 
-| Example                                                                                   | Level        | Description                                                                                         |
-| ----------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------- |
-| [`docker-redis-local-dev`](../examples/setup-redis/docker-redis-local-dev.md)             | Basic        | Provision Redis with Docker Compose and connect a FrontMCP server for local session storage.        |
-| [`hybrid-vercel-kv-with-pubsub`](../examples/setup-redis/hybrid-vercel-kv-with-pubsub.md) | Advanced     | Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions. |
-| [`vercel-kv-serverless`](../examples/setup-redis/vercel-kv-serverless.md)                 | Intermediate | Configure a FrontMCP server with Vercel KV as the session store for serverless deployment.          |
+| Example                                                                                   | Level        | Description                                                                                                                                   |
+| ----------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`docker-redis-local-dev`](../examples/setup-redis/docker-redis-local-dev.md)             | Basic        | Provision Redis with Docker Compose and connect a FrontMCP server for local session storage.                                                  |
+| [`hybrid-vercel-kv-with-pubsub`](../examples/setup-redis/hybrid-vercel-kv-with-pubsub.md) | Advanced     | Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions in distributed multi-instance deployments. |
+| [`vercel-kv-serverless`](../examples/setup-redis/vercel-kv-serverless.md)                 | Intermediate | Configure a FrontMCP server with Vercel KV as the session store for serverless deployment.                                                    |
 
 > See all examples in [`examples/setup-redis/`](../examples/setup-redis/)
 

package/catalog/frontmcp-testing/examples/test-direct-client/basic-create-test.md

@@ -19,9 +19,7 @@ Test tools in-memory without any HTTP overhead using the `create()` function fro
 
 ```typescript
 // src/__tests__/direct-client.spec.ts
-import { create } from '@frontmcp/sdk';
-import { tool } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { create, tool, z } from '@frontmcp/sdk';
 
 const AddTool = tool({
   name: 'add',

package/catalog/frontmcp-testing/examples/test-direct-client/openai-claude-format-test.md

@@ -19,9 +19,7 @@ Verify that tools are returned in the correct format for OpenAI and Claude clien
 
 ```typescript
 // src/__tests__/client-formats.spec.ts
-import { connectOpenAI } from '@frontmcp/sdk';
-import { tool } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { connectOpenAI, tool, z } from '@frontmcp/sdk';
 
 const AddTool = tool({
   name: 'add',

package/catalog/frontmcp-testing/examples/test-tool-unit/schema-validation-test.md

@@ -19,8 +19,8 @@ Validate that a tool's Zod input schema rejects invalid data before `execute()`
 
 ```typescript
 // src/tools/__tests__/add.tool.schema.spec.ts
-import { z } from 'zod';
-import { ToolContext } from '@frontmcp/sdk';
+import { ToolContext, z } from '@frontmcp/sdk';
+
 import { AddTool } from '../add.tool';
 
 describe('AddTool schema validation', () => {

package/catalog/frontmcp-testing/references/test-direct-client.md

@@ -8,9 +8,7 @@ description: In-memory testing with create() and connectOpenAI/connectClaude wit
 Uses `connect()` or `create()` for in-memory testing without HTTP overhead.
 
 ```typescript
-import { create, connectOpenAI } from '@frontmcp/sdk';
-import { tool } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { connectOpenAI, create, tool, z } from '@frontmcp/sdk';
 
 const AddTool = tool({
   name: 'add',

package/catalog/frontmcp-testing/references/test-tool-unit.md

@@ -6,8 +6,8 @@ description: Unit test a ToolContext execute method with mock context, inputs, a
 # Unit Testing a Tool
 
 ```typescript
-import { z } from 'zod';
-import { ToolContext } from '@frontmcp/sdk';
+import { ToolContext, z } from '@frontmcp/sdk';
+
 import { AddTool } from '../tools/add.tool';
 
 describe('AddTool', () => {

package/catalog/skills-manifest.json

@@ -364,6 +364,77 @@
           "name": "setup-sqlite",
           "description": "Cross-reference to the full SQLite configuration guide in frontmcp-setup",
           "examples": []
+        },
+        {
+          "name": "configure-deployment-targets",
+          "description": "Configure multi-target builds with frontmcp.config.ts for node, distributed, vercel, lambda, cloudflare, browser, cli, and sdk targets",
+          "examples": [
+            {
+              "name": "multi-target-with-security",
+              "description": "Configure a FrontMCP project with node + distributed targets, CSP headers, and HSTS",
+              "level": "intermediate",
+              "tags": ["config", "deployment", "csp", "security", "distributed", "hsts", "multi-target"],
+              "features": [
+                "Using defineConfig() for typed configuration with IDE autocomplete",
+                "Multi-target deployments with per-target server settings",
+                "CSP directives including value-less directives like upgrade-insecure-requests",
+                "Security headers (HSTS, X-Frame-Options, X-Content-Type-Options)",
+                "HA configuration for the distributed target"
+              ]
+            },
+            {
+              "name": "distributed-ha-config",
+              "description": "Configure a distributed deployment target with HA settings for heartbeat, session takeover, and Redis-backed session persistence",
+              "level": "advanced",
+              "tags": ["config", "deployment", "distributed", "ha", "redis", "heartbeat", "session-takeover"],
+              "features": [
+                "Configuring the distributed deployment target with HA options",
+                "Setting custom heartbeat intervals and TTL for pod liveness detection",
+                "Combining server config (CSP, cookies) with HA config in the same target",
+                "Using per-target environment variables for Redis connection"
+              ]
+            },
+            {
+              "name": "json-schema-ide-support",
+              "description": "Use frontmcp.config.json with JSON Schema for VS Code and WebStorm autocomplete",
+              "level": "basic",
+              "tags": ["config", "deployment", "json", "schema", "ide", "autocomplete"],
+              "features": [
+                "Adding $schema field for IDE autocomplete in JSON config files",
+                "Configuring multiple deployment targets in JSON format",
+                "Using the frontmcp.schema.json for property validation and hover docs"
+              ]
+            }
+          ]
+        },
+        {
+          "name": "configure-security-headers",
+          "description": "Configure CSP, HSTS, X-Frame-Options, and X-Content-Type-Options via frontmcp.config server settings",
+          "examples": [
+            {
+              "name": "csp-report-only",
+              "description": "Test CSP policies in report-only mode to identify violations before enforcement",
+              "level": "basic",
+              "tags": ["config", "csp", "security", "report-only", "headers"],
+              "features": [
+                "Enabling CSP in report-only mode with reportUri for violation monitoring",
+                "Using the object-format directives in frontmcp.config",
+                "Verifying report-only header is emitted instead of enforcement header"
+              ]
+            },
+            {
+              "name": "full-production-headers",
+              "description": "Complete security headers configuration for production with CSP enforcement, HSTS preload, and clickjacking protection",
+              "level": "intermediate",
+              "tags": ["config", "csp", "security", "hsts", "production", "headers", "frame-options"],
+              "features": [
+                "Full CSP enforcement with multiple directive types including value-less directives",
+                "HSTS with preload and includeSubDomains for HTTPS enforcement",
+                "X-Frame-Options DENY for clickjacking protection",
+                "Custom headers for additional security controls"
+              ]
+            }
+          ]
         }
       ]
     },
@@ -441,6 +512,23 @@
             }
           ]
         },
+        {
+          "name": "build-for-mcpb",
+          "description": "Package a FrontMCP server as a .mcpb archive that Claude Desktop and other MCPB-aware clients install with one click",
+          "examples": [
+            {
+              "name": "mcpb-bundle-build",
+              "description": "Produce a .mcpb archive for Claude Desktop with metadata, tools, and install-time user_config.",
+              "level": "basic",
+              "tags": ["deployment", "mcpb", "bundle", "claude-desktop", "user-config"],
+              "features": [
+                "Using `frontmcp build --target mcpb` to produce a single `.mcpb` archive",
+                "Translating `setup.steps` into MCPB `user_config` + `${user_config.KEY}` env bindings",
+                "Validating the archive round-trip with `frontmcp mcpb validate`"
+              ]
+            }
+          ]
+        },
         {
           "name": "build-for-sdk",
           "description": "Build a FrontMCP server as an embeddable library with create() and connect() APIs",
@@ -691,6 +779,48 @@
               ]
             }
           ]
+        },
+        {
+          "name": "mcp-client-integration",
+          "description": "Configure MCP clients (Claude Desktop, Claude Code, Cursor, VS Code) to connect to a FrontMCP server via stdio, HTTP, or Unix socket",
+          "examples": [
+            {
+              "name": "stdio-npx",
+              "description": "Publish a FrontMCP server to npm and configure MCP clients to use it with npx --stdio.",
+              "level": "basic",
+              "tags": ["deployment", "stdio", "npx", "npm", "mcp-client", "claude-code", "claude-desktop"],
+              "features": [
+                "Building a FrontMCP server as a distributable CLI bundle",
+                "Configuring package.json bin field for npx execution",
+                "Setting up Claude Code, Claude Desktop, and Cursor to use the server via stdio",
+                "Passing environment variables from MCP client config to the server"
+              ]
+            },
+            {
+              "name": "http-remote",
+              "description": "Connect an MCP client to a FrontMCP server running as an HTTP server, locally or remotely.",
+              "level": "basic",
+              "tags": ["deployment", "http", "mcp-client", "remote", "cloud", "production"],
+              "features": [
+                "Connecting to a local FrontMCP dev server on a custom port",
+                "Connecting to a remote production FrontMCP server with authentication",
+                "Configuring HTTP transport in Claude Code and Claude Desktop",
+                "Using a background daemon on a TCP port for persistent local access"
+              ]
+            },
+            {
+              "name": "stdio-binary-with-env",
+              "description": "Configure a local FrontMCP CLI binary with environment variables and custom arguments in MCP client configs.",
+              "level": "intermediate",
+              "tags": ["deployment", "stdio", "cli", "binary", "env", "mcp-client", "configuration"],
+              "features": [
+                "Pointing MCP clients at a locally installed FrontMCP binary",
+                "Passing database URLs, API keys, and feature flags via environment variables",
+                "Using absolute paths for reliable binary resolution",
+                "Configuring different environments (dev, staging) via env vars"
+              ]
+            }
+          ]
         }
       ]
     },
@@ -2097,6 +2227,24 @@
               ]
             }
           ]
+        },
+        {
+          "name": "distributed-ha",
+          "description": "Deploy FrontMCP across multiple pods with heartbeat, session takeover, and notification relay for zero-downtime failover",
+          "examples": [
+            {
+              "name": "ha-kubernetes-3-replicas",
+              "description": "Deploy FrontMCP with 3 replicas, Redis, and automatic session failover on Kubernetes",
+              "level": "intermediate",
+              "tags": ["ha", "kubernetes", "redis", "distributed", "session-takeover", "heartbeat"],
+              "features": [
+                "Configuring @FrontMcp with Redis for distributed deployment",
+                "Kubernetes Deployment YAML with 3 replicas and readiness probes",
+                "Verifying heartbeat keys and session takeover via redis-cli",
+                "NGINX sticky sessions for session affinity"
+              ]
+            }
+          ]
         }
       ]
     },
@@ -2401,13 +2549,13 @@
             },
             {
               "name": "hybrid-vercel-kv-with-pubsub",
-              "description": "Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions.",
+              "description": "Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions in distributed multi-instance deployments.",
               "level": "advanced",
               "tags": ["setup", "vercel-kv", "redis", "vercel", "session", "hybrid"],
               "features": [
                 "Vercel KV handles sessions (`redis` config) while a real Redis handles pub/sub (`pubsub` config)",
-                "Vercel KV does not support pub/sub operations, so a separate Redis instance is required",
-                "Resources with `subscribe: true` rely on the `pubsub` config for real-time notifications",
+                "Vercel KV does not support pub/sub operations, so a separate Redis instance is required for distributed setups",
+                "Resource subscriptions across multiple server instances rely on the `pubsub` config for cross-instance notifications (single-instance servers use in-memory subscriptions automatically)",
                 "The `pubsub` field accepts `provider: 'redis'` only (no Vercel KV support)"
               ]
             },
@@ -2907,6 +3055,180 @@
           ]
         }
       ]
+    },
+    {
+      "name": "frontmcp-channels",
+      "category": "development",
+      "description": "Use when you want to push real-time notifications into Claude Code sessions. Build webhook channels, chat bridges (WhatsApp, Telegram, Slack), agent completion alerts, job status notifications, or error forwarding. The skill for CHANNELS and NOTIFICATIONS.",
+      "path": "frontmcp-channels",
+      "targets": ["all"],
+      "hasResources": true,
+      "tags": [
+        "channels",
+        "notifications",
+        "claude-code",
+        "webhooks",
+        "messaging",
+        "real-time",
+        "two-way",
+        "whatsapp",
+        "telegram",
+        "slack",
+        "chat-bridge"
+      ],
+      "bundle": ["full"],
+      "references": [
+        {
+          "name": "channel-sources",
+          "description": "Configure different channel source types - webhooks, app events, agent completion, job completion, and manual push",
+          "examples": [
+            {
+              "name": "webhook-github",
+              "description": "Forward GitHub webhook events (PRs, pushes, CI) into Claude Code",
+              "level": "basic",
+              "tags": ["webhook", "github", "ci", "notifications"],
+              "features": [
+                "Webhook source with HTTP POST endpoint",
+                "GitHub event type routing",
+                "Static meta for team context"
+              ]
+            },
+            {
+              "name": "app-errors",
+              "description": "Forward application errors to Claude Code via the in-process event bus",
+              "level": "basic",
+              "tags": ["errors", "app-event", "debugging", "monitoring"],
+              "features": [
+                "App event source with ChannelEventBus",
+                "Error severity classification",
+                "Stack trace forwarding"
+              ]
+            },
+            {
+              "name": "agent-notify",
+              "description": "Notify Claude Code when AI agents complete their tasks",
+              "level": "intermediate",
+              "tags": ["agents", "completion", "notifications", "automation"],
+              "features": [
+                "Agent completion source with ID filtering",
+                "Duration and output reporting",
+                "Integration with agent registry emitter"
+              ]
+            },
+            {
+              "name": "job-completion",
+              "description": "Notify Claude Code when background jobs and workflows complete",
+              "level": "intermediate",
+              "tags": ["jobs", "workflows", "completion", "background", "notifications"],
+              "features": [
+                "Job completion source with name filtering",
+                "Status-aware notification formatting",
+                "Duration and output reporting"
+              ]
+            },
+            {
+              "name": "service-connector",
+              "description": "Build a persistent service connector that lets Claude send and receive messages through WhatsApp, Telegram, or any messaging API",
+              "level": "advanced",
+              "tags": ["service", "connector", "whatsapp", "persistent-connection", "bidirectional"],
+              "features": [
+                "Service source type with onConnect/onDisconnect lifecycle",
+                "Channel-contributed tools for outbound messages",
+                "pushIncoming() for feeding service events into the notification pipeline",
+                "Bidirectional conversation flow"
+              ]
+            },
+            {
+              "name": "file-watcher",
+              "description": "Watch files for changes and notify Claude Code in real-time",
+              "level": "intermediate",
+              "tags": ["file-watcher", "filesystem", "logs", "monitoring", "real-time"],
+              "features": [
+                "File watcher source type with glob patterns",
+                "onConnect lifecycle for starting the watcher",
+                "pushIncoming for streaming file events",
+                "Log file monitoring example"
+              ]
+            },
+            {
+              "name": "replay-buffer",
+              "description": "Buffer channel events so Claude Code receives them when it connects, even if events occurred while offline",
+              "level": "advanced",
+              "tags": ["replay", "buffer", "persistence", "offline", "reconnect"],
+              "features": [
+                "Replay configuration with maxEvents cap",
+                "In-memory ring buffer for event storage",
+                "Replay on session connect",
+                "Persistent store pattern with onConnect"
+              ]
+            }
+          ]
+        },
+        {
+          "name": "channel-two-way",
+          "description": "Build two-way chat bridges connecting WhatsApp, Telegram, Slack, and Discord to Claude Code",
+          "examples": [
+            {
+              "name": "whatsapp-bridge",
+              "description": "Full WhatsApp Business API bridge allowing users to chat with Claude Code via WhatsApp",
+              "level": "advanced",
+              "tags": ["whatsapp", "chat", "two-way", "messaging", "bridge"],
+              "features": [
+                "Two-way channel with reply support",
+                "WhatsApp Cloud API integration",
+                "Sender verification and allowlisting",
+                "Webhook signature validation"
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "frontmcp-authorities",
+      "category": "development",
+      "description": "Use when implementing authorization, access control, RBAC, ABAC, or ReBAC for tools, resources, or prompts. Covers JWT claims mapping, authority profiles, and policy enforcement.",
+      "path": "frontmcp-authorities",
+      "targets": ["all"],
+      "hasResources": true,
+      "tags": [
+        "authorization",
+        "rbac",
+        "abac",
+        "rebac",
+        "security",
+        "permissions",
+        "roles",
+        "access-control",
+        "authorities",
+        "jwt"
+      ],
+      "bundle": ["full"],
+      "priority": 9,
+      "visibility": "both",
+      "license": "Apache-2.0",
+      "references": [
+        {
+          "name": "claims-mapping",
+          "description": "JWT claims mapping per identity provider (Auth0, Keycloak, Okta, Cognito, Frontegg)",
+          "examples": []
+        },
+        {
+          "name": "authority-profiles",
+          "description": "Registering and using named authority profiles for reusable access patterns",
+          "examples": []
+        },
+        {
+          "name": "rbac-abac-rebac",
+          "description": "Comparison of RBAC, ABAC, and ReBAC authorization models with usage guidance",
+          "examples": []
+        },
+        {
+          "name": "custom-evaluators",
+          "description": "Creating custom authority evaluators for domain-specific access control",
+          "examples": []
+        }
+      ]
     }
   ]
 }