claude-code-tutor 1.0.0

package/skills-fallback/cc-hooks-guide/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: cc-hooks-guide
+description: "Guía práctica de hooks con ejemplos: notificaciones, auto-format, bloquear archivos, re-inyectar contexto, auto-approve."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/hooks-guide.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Automate workflows with hooks
+
+> Run shell commands automatically when Claude Code edits files, finishes tasks, or needs input. Format code, send notifications, validate commands, and enforce project rules.
+
+Hooks are user-defined shell commands that execute at specific points in Claude Code's lifecycle. They provide deterministic control over Claude Code's behavior, ensuring certain actions always happen rather than relying on the LLM to choose to run them. Use hooks to enforce project rules, automate repetitive tasks, and integrate Claude Code with your existing tools.
+
+For decisions that require judgment rather than deterministic rules, you can also use [prompt-based hooks](#prompt-based-hooks) or [agent-based hooks](#agent-based-hooks) that use a Claude model to evaluate conditions.
+
+For other ways to extend Claude Code, see [skills](/en/skills) for giving Claude additional instructions and executable commands, [subagents](/en/sub-agents) for running tasks in isolated contexts, and [plugins](/en/plugins) for packaging extensions to share across projects.
+
+## Set up your first hook
+
+To create a hook, add a `hooks` block to a [settings file](#configure-hook-location). This walkthrough creates a desktop notification hook, so you get alerted whenever Claude is waiting for your input instead of watching the terminal.
+
+````
+```json  theme={null}
+{
+  "hooks": {
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+If your settings file already has a `hooks` key, merge the `Notification` entry into it rather than replacing the whole object. You can also ask Claude to write the hook for you by describing what you want in the CLI.
+````
+
+  </Step>
+
+  <Step title="Verify the configuration">
+    Type `/hooks` to open the hooks browser. You'll see a list of all available hook events, with a count next to each event that has hooks configured. Select `Notification` to confirm your new hook appears in the list. Selecting the hook shows its details: the event, matcher, type, source file, and command.
+  </Step>
+
+  <Step title="Test the hook">
+    Press `Esc` to return to the CLI. Ask Claude to do something that requires permission, then switch away from the terminal. You should receive a desktop notification.
+  </Step>
+</Steps>

package/skills-fallback/cc-hooks-io/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: cc-hooks-io
+description: "Esquemas JSON de input/output, exit codes, decisiones"
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/hooks.md"
+---
+## Hook input and output
+
+Command hooks receive JSON data via stdin and communicate results through exit codes, stdout, and stderr. HTTP hooks receive the same JSON as the POST request body and communicate results through the HTTP response body. This section covers fields and behavior common to all events. Each event's section under [Hook events](#hook-events) includes its specific input schema and decision control options.

package/skills-fallback/cc-learning-path/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: cc-learning-path
+description: "Ruta de aprendizaje estructurada de Claude Code por niveles: beginner, intermediate y advanced. Úsame cuando el usuario quiera ver el currículo completo, saber qué aprender después, o pida un plan de estudio. Invócame con /cc-learning-path."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "static"
+---
+# Claude Code — Learning Path
+> Powered by claude-code-tutor · Skills sincronizadas con docs oficiales
+
+## Cómo usar esta guía
+Cada nivel incluye conceptos, el skill de referencia disponible en tu sesión,
+y un ejercicio práctico para validar que lo dominaste.
+
+---
+
+## Beginner
+
+| Tema | Skill de referencia | Ejercicio |
+|---|---|---|
+| Instalación y primer uso | — | Abrir Claude Code en un proyecto real |
+| Permission modes | `cc-permissions` | Alternar entre default y plan mode |
+| CLAUDE.md básico | `cc-memory` | Crear un CLAUDE.md para tu proyecto |
+| Comandos built-in | `cc-commands` | Usar /compact y /cost en una sesión larga |
+| Git workflow | `cc-common-workflows` | Crear un commit y PR con Claude Code |
+
+**Checkpoint**: ¿Puedes pedirle a Claude Code que entienda tu codebase
+y haga un cambio con tests en menos de 5 prompts?
+
+---
+
+## Intermediate
+
+| Tema | Skill de referencia | Ejercicio |
+|---|---|---|
+| settings.json completo | `cc-settings` | Configurar permisos fine-grained |
+| Crear una Skill | `cc-skills-guide` | Skill de code review para tu stack |
+| Hook SessionStart | `cc-hooks-events` + `cc-hooks-guide` | Notificación cuando empieza sesión |
+| Hook PostToolUse | `cc-hooks-events` | Auto-format después de editar archivos |
+| MCP server básico | `cc-mcp` | Conectar tu base de datos via MCP |
+| Sub-agents | `cc-sub-agents` | Agente especializado en testing |
+| Worktrees paralelos | `cc-common-workflows` | Dos features en paralelo |
+| Headless en scripts | `cc-headless` | `claude --print` en un npm script |
+
+**Checkpoint**: ¿Tienes hooks que automatizan al menos 2 tareas
+repetitivas de tu flujo de desarrollo?
+
+---
+
+## Advanced
+
+| Tema | Skill de referencia | Ejercicio |
+|---|---|---|
+| Agent teams | `cc-agent-teams` | Equipo de 3 agentes: review, implement, test |
+| Channels + webhooks | `cc-channels` | CI que notifica a sesión activa |
+| Crear un Plugin | `cc-plugins` | Plugin con skills + hooks para tu equipo |
+| GitHub Actions | `cc-github-actions` | @claude en PRs del repo |
+| Sandboxing | `cc-sandboxing` | Habilitar y configurar para el equipo |
+| Model config | `cc-model-config` | opusplan para arquitectura, haiku para tasks rápidas |
+| Scheduled tasks | `cc-scheduled-tasks` | /loop que monitorea deploys |
+
+**Checkpoint**: ¿Tienes Claude Code integrado en tu CI/CD y al menos
+un plugin compartido con tu equipo?
+
+---
+
+## Skills disponibles en esta sesión
+Todas estas skills están sincronizadas con la documentación oficial:
+`cc-changelog` · `cc-hooks-events` · `cc-hooks-config` · `cc-hooks-io` ·
+`cc-hooks-guide` · `cc-mcp` · `cc-settings` · `cc-permissions` ·
+`cc-sub-agents` · `cc-agent-teams` · `cc-skills-guide` · `cc-memory` ·
+`cc-cli-reference` · `cc-commands` · `cc-model-config` · `cc-plugins` ·
+`cc-channels` · `cc-scheduled-tasks` · `cc-headless` · `cc-sandboxing` ·
+`cc-common-workflows` · `cc-best-practices` · `cc-github-actions`
+
+Para ver el estado de sincronización: ejecuta `pulse status` en tu terminal.

package/skills-fallback/cc-mcp-add-mcp-servers-from-json-configuration/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: cc-mcp-add-mcp-servers-from-json-configuration
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Add MCP servers from JSON configuration
+
+If you have a JSON configuration for an MCP server, you can add it directly:
+
+````
+# Example: Adding an HTTP server with JSON configuration
+claude mcp add-json weather-api '{"type":"http","url":"https://api.weather.com/mcp","headers":{"Authorization":"Bearer token"}}'
+
+# Example: Adding a stdio server with JSON configuration
+claude mcp add-json local-weather '{"type":"stdio","command":"/path/to/weather-cli","args":["--api-key","abc123"],"env":{"CACHE_DIR":"/tmp"}}'
+
+# Example: Adding an HTTP server with pre-configured OAuth credentials
+claude mcp add-json my-server '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' --client-secret
+```
+````
+
+  </Step>
+
+  <Step title="Verify the server was added">
+    ```bash  theme={null}
+    claude mcp get weather-api
+    ```
+  </Step>
+</Steps>
+
+- Make sure the JSON is properly escaped in your shell
+- The JSON must conform to the MCP server configuration schema
+- You can use `--scope user` to add the server to your user configuration instead of the project-specific one

package/skills-fallback/cc-mcp-authenticate-with-remote-mcp-servers/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: cc-mcp-authenticate-with-remote-mcp-servers
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Authenticate with remote MCP servers
+
+Many cloud-based MCP servers require authentication. Claude Code supports OAuth 2.0 for secure connections.
+
+````
+```bash  theme={null}
+claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
+```
+````
+
+  </Step>
+
+  <Step title="Use the /mcp command within Claude Code">
+    In Claude code, use the command:
+
+````
+```text  theme={null}
+/mcp
+```
+
+Then follow the steps in your browser to login.
+````
+
+  </Step>
+</Steps>
+
+- Authentication tokens are stored securely and refreshed automatically
+- Use "Clear authentication" in the `/mcp` menu to revoke access
+- If your browser doesn't open automatically, copy the provided URL and open it manually
+- If the browser redirect fails with a connection error after authenticating, paste the full callback URL from your browser's address bar into the URL prompt that appears in Claude Code
+- OAuth authentication works with HTTP servers
+
+### Use a fixed OAuth callback port
+
+Some MCP servers require a specific redirect URI registered in advance. By default, Claude Code picks a random available port for the OAuth callback. Use `--callback-port` to fix the port so it matches a pre-registered redirect URI of the form `http://localhost:PORT/callback`.
+
+You can use `--callback-port` on its own (with dynamic client registration) or together with `--client-id` (with pre-configured credentials).
+
+```bash theme={null}
+# Fixed callback port with dynamic client registration
+claude mcp add --transport http \
+  --callback-port 8080 \
+  my-server https://mcp.example.com/mcp
+```

package/skills-fallback/cc-mcp-import-mcp-servers-from-claude-desktop/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: cc-mcp-import-mcp-servers-from-claude-desktop
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Import MCP servers from Claude Desktop
+
+If you've already configured MCP servers in Claude Desktop, you can import them:
+
+  <Step title="Select which servers to import">
+    After running the command, you'll see an interactive dialog that allows you to select which servers you want to import.
+  </Step>
+
+  <Step title="Verify the servers were imported">
+    ```bash  theme={null}
+    claude mcp list 
+    ```
+  </Step>
+</Steps>
+
+- This feature only works on macOS and Windows Subsystem for Linux (WSL)
+- It reads the Claude Desktop configuration file from its standard location on those platforms
+- Use the `--scope user` flag to add servers to your user configuration
+- Imported servers will have the same names as in Claude Desktop
+- If servers with the same names already exist, they will get a numerical suffix (for example, `server_1`)

package/skills-fallback/cc-mcp-installing-mcp-servers/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: cc-mcp-installing-mcp-servers
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Installing MCP servers
+
+MCP servers can be configured in three different ways depending on your needs:
+
+### Option 1: Add a remote HTTP server
+
+HTTP servers are the recommended option for connecting to remote MCP servers. This is the most widely supported transport for cloud-based services.
+
+```bash theme={null}
+# Basic syntax
+claude mcp add --transport http <name> <url>
+
+# Real example: Connect to Notion
+claude mcp add --transport http notion https://mcp.notion.com/mcp
+
+# Example with Bearer token
+claude mcp add --transport http secure-api https://api.example.com/mcp \
+  --header "Authorization: Bearer your-token"
+```
+
+### Option 2: Add a remote SSE server
+
+```bash theme={null}
+# Basic syntax
+claude mcp add --transport sse <name> <url>
+
+# Real example: Connect to Asana
+claude mcp add --transport sse asana https://mcp.asana.com/sse
+
+# Example with authentication header
+claude mcp add --transport sse private-api https://api.company.com/sse \
+  --header "X-API-Key: your-key-here"
+```
+
+### Option 3: Add a local stdio server
+
+Stdio servers run as local processes on your machine. They're ideal for tools that need direct system access or custom scripts.
+
+```bash theme={null}
+# Basic syntax
+claude mcp add [options] <name> -- <command> [args...]
+
+# Real example: Add Airtable server
+claude mcp add --transport stdio --env AIRTABLE_API_KEY=YOUR_KEY airtable \
+  -- npx -y airtable-mcp-server
+```
+
+All options (`--transport`, `--env`, `--scope`, `--header`) must come **before** the server name. The `--` (double dash) then separates the server name from the command and arguments that get passed to the MCP server.
+
+For example:
+
+- `claude mcp add --transport stdio myserver -- npx server` → runs `npx server`
+- `claude mcp add --transport stdio --env KEY=value myserver -- python server.py --port 8080` → runs `python server.py --port 8080` with `KEY=value` in environment
+
+This prevents conflicts between Claude's flags and the server's flags.
+
+
+### Managing your servers
+
+Once configured, you can manage your MCP servers with these commands:
+
+```bash theme={null}
+# List all configured servers
+claude mcp list
+
+# Get details for a specific server
+claude mcp get github
+
+# Remove a server
+claude mcp remove github
+
+# (within Claude Code) Check server status
+/mcp
+```
+
+### Dynamic tool updates
+
+Claude Code supports MCP `list_changed` notifications, allowing MCP servers to dynamically update their available tools, prompts, and resources without requiring you to disconnect and reconnect. When an MCP server sends a `list_changed` notification, Claude Code automatically refreshes the available capabilities from that server.

package/skills-fallback/cc-mcp-managed-mcp-configuration/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: cc-mcp-managed-mcp-configuration
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Managed MCP configuration
+
+For organizations that need centralized control over MCP servers, Claude Code supports two configuration options:
+
+1. **Exclusive control with `managed-mcp.json`**: Deploy a fixed set of MCP servers that users cannot modify or extend
+2. **Policy-based control with allowlists/denylists**: Allow users to add their own servers, but restrict which ones are permitted
+
+These options allow IT administrators to:
+
+- **Control which MCP servers employees can access**: Deploy a standardized set of approved MCP servers across the organization
+- **Prevent unauthorized MCP servers**: Restrict users from adding unapproved MCP servers
+- **Disable MCP entirely**: Remove MCP functionality completely if needed
+
+### Option 1: Exclusive control with managed-mcp.json
+
+When you deploy a `managed-mcp.json` file, it takes **exclusive control** over all MCP servers. Users cannot add, modify, or use any MCP servers other than those defined in this file. This is the simplest approach for organizations that want complete control.
+
+System administrators deploy the configuration file to a system-wide directory:
+
+- macOS: `/Library/Application Support/ClaudeCode/managed-mcp.json`
+- Linux and WSL: `/etc/claude-code/managed-mcp.json`
+- Windows: `C:\Program Files\ClaudeCode\managed-mcp.json`
+
+The `managed-mcp.json` file uses the same format as a standard `.mcp.json` file:
+
+```json theme={null}
+{
+  "mcpServers": {
+    "github": {
+      "type": "http",
+      "url": "https://api.githubcopilot.com/mcp/"
+    },
+    "sentry": {
+      "type": "http",
+      "url": "https://mcp.sentry.dev/mcp"
+    },
+    "company-internal": {
+      "type": "stdio",
+      "command": "/usr/local/bin/company-mcp-server",
+      "args": ["--config", "/etc/company/mcp-config.json"],
+      "env": {
+        "COMPANY_API_URL": "https://internal.company.com"
+      }
+    }
+  }
+}
+```

package/skills-fallback/cc-mcp-mcp-installation-scopes/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: cc-mcp-mcp-installation-scopes
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## MCP installation scopes
+
+MCP servers can be configured at three different scope levels, each serving distinct purposes for managing server accessibility and sharing. Understanding these scopes helps you determine the best way to configure servers for your specific needs.
+
+### Local scope
+
+Local-scoped servers represent the default configuration level and are stored in `~/.claude.json` under your project's path. These servers remain private to you and are only accessible when working within the current project directory. This scope is ideal for personal development servers, experimental configurations, or servers containing sensitive credentials that shouldn't be shared.
+
+```bash theme={null}
+# Add a local-scoped server (default)
+claude mcp add --transport http stripe https://mcp.stripe.com
+
+# Explicitly specify local scope
+claude mcp add --transport http stripe --scope local https://mcp.stripe.com
+```
+
+### Project scope
+
+Project-scoped servers enable team collaboration by storing configurations in a `.mcp.json` file at your project's root directory. This file is designed to be checked into version control, ensuring all team members have access to the same MCP tools and services. When you add a project-scoped server, Claude Code automatically creates or updates this file with the appropriate configuration structure.
+
+```bash theme={null}
+# Add a project-scoped server
+claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp
+```
+
+The resulting `.mcp.json` file follows a standardized format:
+
+```json theme={null}
+{
+  "mcpServers": {
+    "shared-server": {
+      "command": "/path/to/server",
+      "args": [],
+      "env": {}
+    }
+  }
+}
+```
+
+For security reasons, Claude Code prompts for approval before using project-scoped servers from `.mcp.json` files. If you need to reset these approval choices, use the `claude mcp reset-project-choices` command.
+
+### User scope
+
+User-scoped servers are stored in `~/.claude.json` and provide cross-project accessibility, making them available across all projects on your machine while remaining private to your user account. This scope works well for personal utility servers, development tools, or services you frequently use across different projects.
+
+```bash theme={null}
+# Add a user server
+claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic
+```

package/skills-fallback/cc-mcp-mcp-output-limits-and-warnings/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: cc-mcp-mcp-output-limits-and-warnings
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## MCP output limits and warnings
+
+When MCP tools produce large outputs, Claude Code helps manage the token usage to prevent overwhelming your conversation context:
+
+- **Output warning threshold**: Claude Code displays a warning when any MCP tool output exceeds 10,000 tokens
+- **Configurable limit**: You can adjust the maximum allowed MCP output tokens using the `MAX_MCP_OUTPUT_TOKENS` environment variable
+- **Default limit**: The default maximum is 25,000 tokens
+
+To increase the limit for tools that produce large outputs:
+
+```bash theme={null}
+export MAX_MCP_OUTPUT_TOKENS=50000
+claude
+```
+
+This is particularly useful when working with MCP servers that:
+
+- Query large datasets or databases
+- Generate detailed reports or documentation
+- Process extensive log files or debugging information
+
+### Override result size per tool
+
+If you're building an MCP server, you can allow individual tools to return results larger than the default persist-to-disk threshold by setting `_meta["anthropic/maxResultSizeChars"]` in the tool's `tools/list` response entry. Claude Code raises that tool's threshold to the annotated value, up to a hard ceiling of 500,000 characters.
+
+This is useful for tools that return inherently large but necessary outputs, such as database schemas or full file trees. Without the annotation, results that exceed the default threshold are persisted to disk and replaced with a file reference in the conversation.
+
+```json theme={null}
+{
+  "name": "get_schema",
+  "description": "Returns the full database schema",
+  "_meta": {
+    "anthropic/maxResultSizeChars": 500000
+  }
+}
+```
+
+The annotation raises the per-tool persist threshold but does not bypass the global `MAX_MCP_OUTPUT_TOKENS` limit, which defaults to 25,000 tokens or roughly 100,000 characters. To return results larger than that, users must also raise `MAX_MCP_OUTPUT_TOKENS`.

package/skills-fallback/cc-mcp-popular-mcp-servers/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: cc-mcp-popular-mcp-servers
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Popular MCP servers
+
+Here are some commonly used MCP servers you can connect to Claude Code:

package/skills-fallback/cc-mcp-practical-examples/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: cc-mcp-practical-examples
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Practical examples
+
+{/\* ### Example: Automate browser testing with Playwright
+
+```bash
+claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest
+```
+
+Then write and run browser tests:
+
+```text
+Test if the login flow works with test@example.com
+```
+
+```text
+Take a screenshot of the checkout page on mobile
+```
+
+````text
+Verify that the search feature returns results
+``` */}
+
+### Example: Monitor errors with Sentry
+
+```bash  theme={null}
+claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
+````
+
+Authenticate with your Sentry account:
+
+```text theme={null}
+/mcp
+```
+
+Then debug production issues:
+
+```text theme={null}
+What are the most common errors in the last 24 hours?
+```
+
+```text theme={null}
+Show me the stack trace for error ID abc123
+```
+
+```text theme={null}
+Which deployment introduced these new errors?
+```
+
+### Example: Connect to GitHub for code reviews
+
+```bash theme={null}
+claude mcp add --transport http github https://api.githubcopilot.com/mcp/
+```
+
+Authenticate if needed by selecting "Authenticate" for GitHub:
+
+```text theme={null}
+/mcp
+```
+
+Then work with GitHub:
+
+```text theme={null}
+Review PR #456 and suggest improvements
+```
+
+```text theme={null}
+Create a new issue for the bug we just found
+```
+
+```text theme={null}
+Show me all open PRs assigned to me
+```
+
+### Example: Query your PostgreSQL database
+
+```bash theme={null}
+claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
+  --dsn "postgresql://readonly:pass@prod.db.com:5432/analytics"
+```
+
+Then query your database naturally:
+
+```text theme={null}
+What's our total revenue this month?
+```
+
+```text theme={null}
+Show me the schema for the orders table
+```
+
+```text theme={null}
+Find customers who haven't made a purchase in 90 days
+```

package/skills-fallback/cc-mcp-respond-to-mcp-elicitation-requests/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: cc-mcp-respond-to-mcp-elicitation-requests
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Respond to MCP elicitation requests
+
+MCP servers can request structured input from you mid-task using elicitation. When a server needs information it can't get on its own, Claude Code displays an interactive dialog and passes your response back to the server. No configuration is required on your side: elicitation dialogs appear automatically when a server requests them.
+
+Servers can request input in two ways:
+
+- **Form mode**: Claude Code shows a dialog with form fields defined by the server (for example, a username and password prompt). Fill in the fields and submit.
+- **URL mode**: Claude Code opens a browser URL for authentication or approval. Complete the flow in the browser, then confirm in the CLI.
+
+To auto-respond to elicitation requests without showing a dialog, use the [`Elicitation` hook](/en/hooks#elicitation).
+
+If you're building an MCP server that uses elicitation, see the [MCP elicitation specification](https://modelcontextprotocol.io/docs/learn/client-concepts#elicitation) for protocol details and schema examples.