65 65 

66Las reglas se evalúan en orden: deny, luego ask, luego allow. La primera coincidencia en ese orden determina el resultado, y la especificidad de la regla no cambia el orden.66Las reglas se evalúan en orden: deny, luego ask, luego allow. La primera coincidencia en ese orden determina el resultado, y la especificidad de la regla no cambia el orden.

67 67 

68Una regla deny amplia como `Bash(aws *)` bloquea cada llamada coincidente, incluidas las llamadas que también coinciden con una regla allow más específica como `Bash(aws s3 ls)`, por lo que una regla deny no puede llevar excepciones de lista de permitidos. La misma precedencia se aplica entre ask y allow: una regla ask coincidente solicita confirmación incluso cuando una regla allow más específica también coincide con la misma llamada.68Una regla deny amplia como `Bash(aws *)` bloquea cada llamada coincidente, incluidas las llamadas que también coinciden con una regla allow más específica como `Bash(aws s3 ls)`. Una regla allow no puede crear una excepción dentro de una regla deny. La misma precedencia se aplica entre ask y allow: una regla ask coincidente solicita confirmación incluso cuando una regla allow más específica también coincide con la misma llamada.

69 69 

70Las reglas deny se comportan de manera diferente dependiendo de si nombran una herramienta o delimitan un patrón dentro de una. Un nombre de herramienta simple como `Bash` elimina la herramienta del contexto de Claude por completo, por lo que Claude nunca la ve. Si agrega tal regla a mitad de sesión, Claude no puede llamar a la herramienta desde su siguiente llamada de herramienta en adelante; [Denying an entire tool](/docs/es/prompt-caching#denying-an-entire-tool) cubre lo que sucede con una definición que Claude ya ha visto. Una regla delimitada como `Bash(rm *)` deja la herramienta disponible y bloquea las llamadas coincidentes cuando Claude intenta usarlas.70Las reglas deny se comportan de manera diferente dependiendo de si nombran una herramienta o delimitan un patrón dentro de una. Un nombre de herramienta simple como `Bash` elimina la herramienta del contexto de Claude por completo, por lo que Claude nunca la ve. Si agrega tal regla a mitad de sesión, Claude no puede llamar a la herramienta desde su siguiente llamada de herramienta en adelante; [Denying an entire tool](/docs/es/prompt-caching#denying-an-entire-tool) cubre lo que sucede con una definición que Claude ya ha visto. Una regla delimitada como `Bash(rm *)` deja la herramienta disponible y bloquea las llamadas coincidentes cuando Claude intenta usarlas.

71 71 

236 Bash236 Bash

237</h3>237</h3>

238 238 

239Las reglas de Bash coinciden con el texto completo del comando, con `*` representando cualquier texto. [Patrones de comodín](#wildcard-patterns) muestra qué comandos coincide cada forma de regla y dónde colocar el `*`. El resto de esta sección cubre cómo Claude Code coincide con comandos compuestos y envoltorios, qué no coincide una regla, comandos de solo lectura y redirecciones.239Las reglas de Bash coinciden con el texto completo del comando, siendo `*` un comodín para cualquier texto. [Wildcard patterns](#wildcard-patterns) muestra qué comandos coinciden con cada forma de regla y dónde poner el `*`. El resto de esta sección cubre cómo Claude Code coincide con comandos compuestos y envoltorios, qué no coincide una regla, comandos de solo lectura y redirecciones.

240 240 

241<h4 id="compound-commands">241<h4 id="compound-commands">

242 Comandos compuestos242 Comandos compuestos

243</h4>243</h4>

244 244 

245<Tip>245<Tip>

246 Claude Code es consciente de los operadores de shell, por lo que una regla como `Bash(safe-cmd *)` no le dará permiso para ejecutar el comando `safe-cmd && other-cmd`. Los separadores de comando reconocidos son `&&`, `||`, `;`, `|`, `|&`, `&` y saltos de línea. Una regla debe coincidir con cada subcomando de forma independiente.246 Claude Code es consciente de los operadores de shell, por lo que una regla como `Bash(safe-cmd *)` no le dará permiso para ejecutar el comando `safe-cmd && other-cmd`. Los separadores de comandos reconocidos son `&&`, `||`, `;`, `|`, `|&`, `&` y saltos de línea. Una regla debe coincidir con cada subcomando de forma independiente.

247</Tip>247</Tip>

248 248 

249Las reglas de negación y solicitud se aplican cuando cualquier subcomando coincide con ellas, incluyendo un comando anidado dentro de un subshell, una sustitución de comando o un cuerpo de flujo de control como un bucle `for`. Una regla de solicitud como `Bash(git clean *)` aún le solicita para `cd /tmp && git clean -f` o `echo "$(git clean -f)"`, incluso en [modo automático](/docs/es/permission-modes#eliminate-prompts-with-auto-mode).249Las reglas de negación y solicitud se aplican cuando cualquier subcomando coincide con ellas, incluido un comando anidado dentro de un subshell, una sustitución de comandos o un cuerpo de flujo de control como un bucle `for`. Una regla de solicitud como `Bash(git clean *)` aún le solicita aprobación para `cd /tmp && git clean -f` o `echo "$(git clean -f)"`, incluso en [modo automático](/docs/es/permission-modes#eliminate-prompts-with-auto-mode).

250 250 

251Cuando `&&` o `||` no tiene nada después, como en `npm test &&`, Claude Code trata el comando como no analizable y no lo divide en subcomandos para coincidencia de reglas de permiso, por lo que una regla como `Bash(npm *)` no lo aprueba.251Cuando `&&` o `||` no tiene nada después, como en `npm test &&`, Claude Code trata el comando como no analizable y no lo divide en subcomandos para coincidencia de reglas de permiso de solo lectura, por lo que una regla como `Bash(npm *)` no la aprueba.

252 252 

253Cuando aprueba un comando compuesto con "Sí, no preguntar de nuevo", Claude Code guarda una regla separada para cada subcomando que requiere aprobación, en lugar de una sola regla para la cadena completa. Por ejemplo, aprobar `git status && npm test` guarda una regla para `npm test`, por lo que futuras invocaciones de `npm test` se reconocen independientemente de lo que preceda a `&&`. Los subcomandos como `cd` en un subdirectorio generan su propia regla Read para esa ruta. Se pueden guardar hasta 5 reglas para un solo comando compuesto.253Cuando aprueba un comando compuesto con "Sí, y no vuelvas a preguntar", Claude Code guarda una regla separada para cada subcomando que requiere aprobación, en lugar de una única regla para la cadena completa. Por ejemplo, aprobar `git status && npm test` guarda una regla para `npm test`, por lo que las invocaciones futuras de `npm test` se reconocen independientemente de lo que preceda a `&&`. Los subcomandos como `cd` en un subdirectorio generan su propia regla Read para esa ruta. Se pueden guardar hasta 5 reglas para un único comando compuesto.

254 254 

255<h4 id="process-wrappers">255<h4 id="process-wrappers">

256 Envoltorios256 Envoltorios

257</h4>257</h4>

258 258 

259Antes de coincidir con reglas de Bash, Claude Code elimina un conjunto fijo de envoltorios, por lo que una regla como `Bash(npm test *)` también coincide con `timeout 30 npm test`. Los envoltorios eliminados son `timeout`, `time`, `nice`, `nohup` y `stdbuf`, más los builtins de shell `command` y `builtin`, y `noglob` de zsh. Cada uno ejecuta su argumento como el comando real. Dos formas relacionadas no se eliminan: la forma de consulta `command -v`, que busca un comando en lugar de ejecutarlo, y `nocorrect` de zsh.259Antes de coincidir con las reglas de Bash, Claude Code elimina un conjunto fijo de envoltorios, por lo que una regla como `Bash(npm test *)` también coincide con `timeout 30 npm test`. Los envoltorios eliminados son `timeout`, `time`, `nice`, `nohup` y `stdbuf`, más los builtins de shell `command` y `builtin`, y `noglob` de zsh. Cada uno ejecuta su argumento como el comando real. Dos formas relacionadas no se eliminan: la forma de consulta `command -v`, que busca un comando en lugar de ejecutarlo, y `nocorrect` de zsh.

260 260 

261Claude Code también elimina una asignación inicial de ciertas variables de entorno conocidas como seguras, por lo que `Bash(npm test *)` coincide con `NODE_ENV=test npm test`. Una regla de permiso no coincidirá más allá de una asignación de cualquier otra variable. Una regla de negación o solicitud coincide más allá de cualquier asignación inicial, por lo que `Bash(rm *)` en negación aún coincide con `FOO=bar rm -rf tmp/`.261Claude Code también elimina una asignación inicial de ciertas variables de entorno conocidas como seguras, por lo que `Bash(npm test *)` coincide con `NODE_ENV=test npm test`. Una regla de permiso no coincidirá más allá de una asignación de cualquier otra variable. Una regla de negación o solicitud coincide más allá de cualquier asignación inicial, por lo que `Bash(rm *)` en negación aún coincide con `FOO=bar rm -rf tmp/`.

262 262 

263`xargs` desnudo también se elimina, por lo que `Bash(grep *)` coincide con `xargs grep pattern`. La eliminación solo se aplica cuando `xargs` no tiene banderas: una invocación como `xargs -n1 grep pattern` se coincide como un comando `xargs`, por lo que las reglas escritas para el comando interno no la cubren.263`xargs` desnudo también se elimina, por lo que `Bash(grep *)` coincide con `xargs grep pattern`. La eliminación se aplica solo cuando `xargs` no tiene banderas: una invocación como `xargs -n1 grep pattern` se coincide como un comando `xargs`, por lo que las reglas escritas para el comando interno no la cubren.

264 264 

265Esta lista de envoltorios está integrada y no es configurable. Los ejecutores de entorno de desarrollo como `direnv exec`, `devbox run`, `mise exec`, `npx` y `docker exec` no están en la lista. Porque estas herramientas ejecutan sus argumentos como un comando, una regla como `Bash(devbox run *)` coincide con lo que viene después de `run`, incluyendo `devbox run rm -rf .`. Para aprobar trabajo dentro de un ejecutor de entorno, escriba una regla específica que incluya tanto el ejecutor como el comando interno, como `Bash(devbox run npm test)`. Agregue una regla por comando interno que desee permitir.265Esta lista de envoltorios está integrada y no es configurable. Los ejecutores de entorno de desarrollo como `direnv exec`, `devbox run`, `mise exec`, `npx` y `docker exec` no están en la lista. Debido a que estas herramientas ejecutan sus argumentos como un comando, una regla como `Bash(devbox run *)` coincide con lo que viene después de `run`, incluido `devbox run rm -rf .`. Para aprobar el trabajo dentro de un ejecutor de entorno, escriba una regla específica que incluya tanto el ejecutor como el comando interno, como `Bash(devbox run npm test)`. Agregue una regla por cada comando interno que desee permitir.

266 266 

267Los envoltorios exec como `watch`, `setsid`, `ionice` y `flock` no pueden ser auto-aprobados por una regla de prefijo como `Bash(watch *)`, por lo que en modo Manual siempre solicitan. Lo mismo se aplica a `find` con `-exec` o `-delete`: una regla `Bash(find *)` no cubre estas formas. Para aprobar una invocación específica, escriba una regla de coincidencia exacta para la cadena de comando completa.267Los envoltorios Exec como `watch`, `setsid`, `ionice` y `flock` no pueden ser aprobados automáticamente por una regla de prefijo como `Bash(watch *)`, por lo que en modo Manual siempre solicitan aprobación. Lo mismo se aplica a `find` con `-exec` o `-delete`: una regla `Bash(find *)` no cubre estas formas. Para aprobar una invocación específica, escriba una regla de coincidencia exacta para la cadena de comando completa.

268 268 

269<h4 id="bash-rule-limits">269<h4 id="bash-rule-limits">

270 Lo que una regla de Bash no coincide270 Qué no coincide una regla de Bash

271</h4>271</h4>

272 272 

273Una regla de Bash coincide con el texto del comando que Claude escribe, después de que Claude Code divide [comandos compuestos](#compound-commands) y elimina [envoltorios](#process-wrappers). No coincide con el mismo programa invocado en una forma diferente, por lo que una regla de negación o solicitud cubre la invocación que Claude generalmente produce y no es un límite de seguridad alrededor del programa. Estas reglas en `deny` o `ask` detienen la primera forma y no las otras:273Una regla de Bash coincide con el texto del comando que Claude escribe, después de que Claude Code divide [comandos compuestos](#compound-commands) y elimina [envoltorios](#process-wrappers). No coincide con el mismo programa invocado de una forma diferente, por lo que una regla de negación o solicitud cubre la invocación que Claude generalmente produce y no es un límite de seguridad alrededor del programa. Estas reglas en `deny` o `ask` detienen la primera forma y no las otras:

274 274 

275| Regla | Detiene | No detiene |275| Regla | Detiene | No detiene |

276| :----------------- | :------------------------- | :---------------------------------------------------------------------------------------------------- |276| :----------------- | :------------------------- | :---------------------------------------------------------------------------------------------------- |

278| `Bash(rm *)` | `rm -rf build/` | `/bin/rm -rf build/`, `bash -c 'rm -rf build/'` |278| `Bash(rm *)` | `rm -rf build/` | `/bin/rm -rf build/`, `bash -c 'rm -rf build/'` |

279| `Bash(git push *)` | `git push origin main` | `git -C . push origin main`, `git -c push.default=current push origin main`, `git 'push' origin main` |279| `Bash(git push *)` | `git push origin main` | `git -C . push origin main`, `git -c push.default=current push origin main`, `git 'push' origin main` |

280 280 

281Sus otras reglas y el modo de permisos deciden los comandos en la última columna.281Sus otras reglas y el modo de permiso deciden los comandos en la última columna.

282 282 

283Para aplicación de sistema de archivos y red que no dependa del texto del comando, use [sandboxing](/docs/es/sandboxing). Para inspeccionar el texto completo del comando con su propia lógica antes de que se ejecute, use un hook [PreToolUse](#extend-permissions-with-hooks).283Para la aplicación de sistema de archivos y red que no depende del texto del comando, use [sandboxing](/docs/es/sandboxing). Para inspeccionar el texto completo del comando con su propia lógica antes de que se ejecute, use un hook [PreToolUse](#extend-permissions-with-hooks).

284 284 

285<h4 id="read-only-commands">285<h4 id="read-only-commands">

286 Comandos de solo lectura286 Comandos de solo lectura

287</h4>287</h4>

288 288 

289Claude Code reconoce un conjunto integrado de comandos Bash como de solo lectura y los ejecuta sin un aviso de permisos en cada modo, excepto para una ruta que [`permissions.blockReadsOutsideWorkingDirectories`](/docs/es/settings-reference#permissions-blockreadsoutsideworkingdirectories) cierra. El conjunto incluye `ls`, `cat`, `echo`, `pwd`, `head`, `tail`, `grep`, `find`, `wc`, `which`, `diff`, `stat`, `du`, `cd` y formas de solo lectura de `git`. El conjunto no es configurable; para requerir un aviso para uno de estos comandos, agregue una regla `ask` o `deny` para él.289Claude Code reconoce un conjunto integrado de comandos de Bash como de solo lectura y los ejecuta sin una solicitud de permiso en todos los modos, excepto para una ruta que [`permissions.blockReadsOutsideWorkingDirectories`](/docs/es/settings-reference#permissions-blockreadsoutsideworkingdirectories) cierra. El conjunto incluye `ls`, `cat`, `echo`, `pwd`, `head`, `tail`, `grep`, `find`, `wc`, `which`, `diff`, `stat`, `du`, `cd` y formas de solo lectura de `git`. El conjunto no es configurable; para requerir una solicitud para uno de estos comandos, agregue una regla `ask` o `deny` para él.

290 290 

291Una redirección como `ls > out.txt` agrega una verificación en el objetivo. Vea [Redirecciones](#redirections).291Una redirección como `ls > out.txt` agrega una verificación en el destino. Vea [Redirections](#redirections).

292 292 

293Los patrones glob sin comillas se permiten para comandos cuya cada bandera es de solo lectura, por lo que `ls *.ts` y `wc -l src/*.py` se ejecutan sin un aviso.293Los patrones glob sin comillas se permiten para comandos cuya bandera es de solo lectura, por lo que `ls *.ts` y `wc -l src/*.py` se ejecutan sin una solicitud.

294 294 

295En modo Manual, los comandos de este conjunto aún solicitan en estos casos:295En modo Manual, los comandos de este conjunto aún solicitan aprobación en estos casos:

296 296 

297* **Globs sin comillas para comandos con banderas capaces de escritura**: comandos con banderas capaces de escritura o ejecución, como `find`, `sort`, `sed` y `git`, solicitan cuando un glob sin comillas está presente, porque el glob podría expandirse a una bandera como `-delete`.297* **Globs sin comillas para comandos con banderas capaces de escritura**: comandos con banderas capaces de escritura o ejecución, como `find`, `sort`, `sed` y `git`, solicitan aprobación cuando hay un glob sin comillas presente, porque el glob podría expandirse a una bandera como `-delete`.

298* **`docker` apuntado a otro daemon**: formas de solo lectura de `docker` solicitan cuando el comando lleva una bandera que selecciona un daemon diferente, como `-H`, `--context` o `--url` y `--connection` de Podman.298* **`docker` apuntado a otro daemon**: formas de solo lectura de `docker` solicitan aprobación cuando el comando lleva una bandera que selecciona un daemon diferente, como `-H`, `--context` o `--url` y `--connection` de Podman.

299* **`file` con banderas de apertura de ruta**: `file` solicita cuando pasa `-m`/`--magic-file` o `-f`/`--files-from`, porque esas banderas hacen que `file` abra las rutas nombradas en el valor de la bandera.299* **`file` con banderas de apertura de ruta**: `file` solicita aprobación cuando pasa `-m`/`--magic-file` o `-f`/`--files-from`, porque esas banderas hacen que `file` abra las rutas nombradas en el valor de la bandera.

300* **Rutas de red en Windows**: un comando cuyos argumentos incluyen una ruta de red (UNC), como `\\server\share\file`, solicita porque acceder a una ruta de red puede enviar sus credenciales de Windows al host que nombra. La misma verificación se aplica a comandos de [herramienta PowerShell](/docs/es/tools-reference#powershell-tool).300* **Rutas de red en Windows**: un comando cuyos argumentos incluyen una ruta de red (UNC), como `\\server\share\file`, solicita aprobación porque acceder a una ruta de red puede enviar sus credenciales de Windows al host que nombra. La misma verificación se aplica a comandos de [herramienta PowerShell](/docs/es/tools-reference#powershell-tool).

301* **Comandos que el análisis no puede analizar**: cuando Claude Code no puede analizar completamente un comando, solicita aprobación en lugar de tratar el comando como de solo lectura. Los comandos más largos que 10,000 caracteres siempre solicitan porque exceden lo que el análisis analiza.301* **Comandos que el análisis no puede analizar**: cuando Claude Code no puede analizar completamente un comando, solicita aprobación en lugar de tratar el comando como de solo lectura. Los comandos más largos que 10,000 caracteres siempre solicitan aprobación porque exceden lo que el análisis analiza.

302 302 

303Un `cd` en una ruta dentro de su directorio de trabajo o un [directorio adicional](#working-directories) también es de solo lectura, y un comando compuesto como `cd packages/api && ls` se ejecuta sin un aviso cuando cada parte se califica por su cuenta. Estas combinaciones solicitan incluso cuando cada parte es de solo lectura:303Un `cd` en una ruta dentro de su directorio de trabajo o un [directorio adicional](#working-directories) también es de solo lectura, y un comando compuesto como `cd packages/api && ls` se ejecuta sin una solicitud cuando cada parte se califica por sí sola. Estas combinaciones solicitan aprobación incluso cuando cada parte es de solo lectura:

304 304 

305* **`cd` con `git`**: solicita cuando el `cd` cambia a un directorio diferente, ya que ejecutar `git` en un nuevo directorio puede ejecutar los hooks de ese directorio. Un `cd` cuyo objetivo se resuelve al directorio de trabajo actual es una no-operación y no activa la solicitud.305* **`cd` con `git`**: solicita aprobación cuando el `cd` cambia a un directorio diferente, ya que ejecutar `git` en un nuevo directorio puede ejecutar los hooks de ese directorio. Un `cd` cuyo destino se resuelve al directorio de trabajo actual es una no-operación y no desencadena la solicitud.

306* **`cd` con una redirección**: solicita cuando Claude Code no puede determinar a qué directorio se resuelve el objetivo de redirección después de que se ejecuta `cd`. Un comando cuyo único objetivo de redirección es `/dev/null`, como `cd app; grep -r pattern . 2>/dev/null`, no solicita, porque `/dev/null` no depende del directorio de trabajo.306* **`cd` con una redirección**: solicita aprobación cuando Claude Code no puede determinar contra qué directorio se resuelve el destino de redirección después de que se ejecuta el `cd`. Un comando cuyo único destino de redirección es `/dev/null`, como `cd app; grep -r pattern . 2>/dev/null`, no solicita aprobación, porque `/dev/null` no depende del directorio de trabajo.

307 307 

308<Warning>308<Warning>

309 Los patrones de permisos de Bash que intentan restringir argumentos de comando son frágiles. Por ejemplo, `Bash(curl http://github.com/ *)` intenta restringir curl a URLs de GitHub, pero no coincidirá con variaciones como:309 Los patrones de permisos de Bash que intentan restringir argumentos de comandos son frágiles. Por ejemplo, `Bash(curl http://github.com/ *)` intenta restringir curl a URLs de GitHub, pero no coincidirá con variaciones como:

310 310 

311 * Opciones antes de URL: `curl -X GET http://github.com/...`311 * Opciones antes de URL: `curl -X GET http://github.com/...`

312 * Protocolo diferente: `curl https://github.com/...`312 * Protocolo diferente: `curl https://github.com/...`

315 315 

316 Para un filtrado de URL más confiable, considere:316 Para un filtrado de URL más confiable, considere:

317 317 

318 * **Restringir herramientas de red de Bash**: use reglas de negación para bloquear `curl`, `wget` y comandos similares, luego use la herramienta WebFetch con permiso `WebFetch(domain:github.com)` para dominios permitidos. Una regla de negación no coincide con el mismo programa por ruta o dentro de `sh -c`, así que emparéjela con la [lista de permitidos de red del sandbox](/docs/es/sandboxing#network-isolation) cuando la restricción debe mantenerse; vea [lo que una regla de Bash no coincide](#bash-rule-limits)318 * **Restringir herramientas de red de Bash**: use reglas de negación para detener `curl`, `wget` y comandos similares, luego use la herramienta WebFetch con permiso `WebFetch(domain:github.com)` para dominios permitidos. Una regla de negación no coincide con el mismo programa por ruta o dentro de `sh -c`, por lo que emparéjela con la [lista de permitidos de red del sandbox](/docs/es/sandboxing#network-isolation) cuando la restricción debe mantenerse; vea [qué no coincide una regla de Bash](#bash-rule-limits)

319 * **Usar hooks PreToolUse**: implemente un hook que valide URLs en comandos Bash y bloquee dominios no permitidos319 * **Usar hooks PreToolUse**: implemente un hook que valide URLs en comandos de Bash y bloquee dominios no permitidos

320 * **Agregar orientación CLAUDE.md**: describa sus patrones curl permitidos en `CLAUDE.md`. Esto forma lo que Claude intenta pero no aplica un límite, así que emparéjelo con una de las opciones anteriores320 * **Agregar orientación CLAUDE.md**: describa sus patrones de curl permitidos en `CLAUDE.md`. Esto forma lo que Claude intenta pero no aplica un límite, por lo que emparéjelo con una de las opciones anteriores

321 321 

322 Tenga en cuenta que usar WebFetch solo no previene el acceso a la red. Si se permite Bash, Claude aún puede usar `curl`, `wget` u otras herramientas para alcanzar cualquier URL.322 Tenga en cuenta que usar WebFetch solo no previene el acceso a la red. Si se permite Bash, Claude aún puede usar `curl`, `wget` u otras herramientas para alcanzar cualquier URL.

323</Warning>323</Warning>

326 Redirecciones326 Redirecciones

327</h4>327</h4>

328 328 

329Cuando un comando redirige salida o entrada, Claude Code verifica el objetivo de redirección contra sus reglas de archivo como si Claude escribiera o leyera ese archivo directamente:329Cuando un comando redirige salida o entrada, Claude Code verifica el destino de redirección contra sus reglas de archivo como si Claude escribiera o leyera ese archivo directamente:

330 330 

331* **Redirecciones de salida**: para `> file`, `>> file` o `2> file`, la verificación cubre sus reglas de permiso y negación `Edit`, [rutas protegidas](/docs/es/permission-modes#protected-paths) y los [directorios de trabajo](#working-directories). Una regla como `Bash(git commit *)` permite el comando, no el objetivo. Un objetivo que comienza con `~` o contiene un carácter de comodín necesita su aprobación.331* **Redirecciones de salida**: para `> file`, `>> file` o `2> file`, la verificación cubre sus reglas de permiso `Edit` de permitir y negar, [rutas protegidas](/docs/es/permission-modes#protected-paths) y los [directorios de trabajo](#working-directories). Una regla como `Bash(git commit *)` permite el comando, no el destino. Un destino que comienza con `~` o contiene un carácter glob necesita su aprobación.

332* **Redirecciones de entrada**: para `< file`, la verificación cubre sus reglas de permiso y negación `Read` y los directorios de trabajo. Un objetivo fuera de los directorios de trabajo necesita su aprobación a menos que una regla de permiso lo cubra. Un objetivo que contiene un patrón de comodín, o una ruta relativa que sigue a un `cd` en el mismo comando, necesita su aprobación incluso cuando una regla de permiso lo cubre. Claude Code verifica objetivos de entrada en v2.1.257 y posterior.332* **Redirecciones de entrada**: para `< file`, la verificación cubre sus reglas de permiso `Read` de permitir y negar y los directorios de trabajo. Un destino fuera de los directorios de trabajo necesita su aprobación a menos que una regla de permiso lo cubra. Un destino que contiene un patrón glob, o una ruta relativa que sigue a un `cd` en el mismo comando, necesita su aprobación incluso cuando una regla de permiso lo cubre. Claude Code verifica destinos de entrada en v2.1.257 y posterior.

333 333 

334Los objetivos sin archivo detrás no se verifican: `/dev/null`, formas de descriptor de archivo como `2>&1` y `<&3`, y here-docs y here-strings.334Los destinos sin archivo detrás no se verifican: `/dev/null`, formas de descriptor de archivo como `2>&1` y `<&3`, y here-docs y here-strings.

335 

336Claude Code también verifica los archivos que escribe un comando `tee`, incluido en un pipeline como `make | tee build.log`. La verificación cubre sus reglas de permiso `Edit` de permitir y negar, [rutas protegidas](/docs/es/permission-modes#protected-paths) y los [directorios de trabajo](#working-directories). Una regla de permiso como `Bash(tee *)` no cubre un destino fuera de los directorios de trabajo. Claude Code verifica destinos de `tee` en v2.1.269 y posterior.

335 337 

336<h3 id="powershell">338<h3 id="powershell">

337 PowerShell339 PowerShell

355 357 

356Los alias comunes se canonicalizan antes de coincidir. Una regla escrita para el nombre del cmdlet también coincide con sus alias, por lo que `PowerShell(Get-ChildItem *)` coincide con `gci`, `ls` y `dir` también. La coincidencia no distingue mayúsculas de minúsculas.358Los alias comunes se canonicalizan antes de coincidir. Una regla escrita para el nombre del cmdlet también coincide con sus alias, por lo que `PowerShell(Get-ChildItem *)` coincide con `gci`, `ls` y `dir` también. La coincidencia no distingue mayúsculas de minúsculas.

357 359 

358Claude Code analiza el AST de PowerShell y verifica cada comando en un comando compuesto de forma independiente. Los operadores de tubería `|`, separadores de declaración `;` y en PowerShell 7+ los operadores de cadena `&&` y `||` dividen un comando compuesto en subcomandos. Una regla debe coincidir con cada subcomando para que se permita el comando compuesto.360Claude Code analiza el AST de PowerShell y verifica cada comando en un comando compuesto de forma independiente. Los operadores de pipeline `|`, separadores de declaración `;` y en PowerShell 7+ los operadores de cadena `&&` y `||` dividen un comando compuesto en subcomandos. Una regla debe coincidir con cada subcomando para que se permita el comando compuesto.

359 361 

360<h3 id="read-and-edit">362<h3 id="read-and-edit">

361 Read y Edit363 Read y Edit

362</h3>364</h3>

363 365 

364Para bloquear las herramientas de archivo de Claude de leer un archivo o directorio, agregue una regla de negación `Read` para su ruta, como `Read(./.env)` o `Read(./secrets/**)`; [Excluir archivos sensibles](/docs/es/settings-reference#exclude-sensitive-files) tiene un ejemplo listo para pegar.366Para bloquear las herramientas de archivo de Claude de leer un archivo o directorio, agregue una regla de negación `Read` para su ruta, como `Read(./.env)` o `Read(./secrets/**)`; [Exclude sensitive files](/docs/es/settings-reference#exclude-sensitive-files) tiene un ejemplo listo para pegar.

365 367 

366Las reglas `Edit` se aplican a todas las herramientas integradas que editan archivos. Claude hace un esfuerzo de mejor intento para aplicar reglas `Read` a todas las herramientas integradas que leen archivos como Grep y Glob, a menciones `@file` en sus indicaciones, y a la selección y contexto de archivo abierto que un [IDE](/docs/es/vs-code#the-built-in-ide-mcp-server) conectado comparte con Claude.368Las reglas `Edit` se aplican a todas las herramientas integradas que editan archivos. Claude hace un esfuerzo de mejor intento para aplicar reglas `Read` a todas las herramientas integradas que leen archivos como Grep y Glob, a menciones `@file` en sus solicitudes y a la selección y contexto de archivo abierto que un [IDE](/docs/es/vs-code#the-built-in-ide-mcp-server) conectado comparte con Claude.

367 369 

368Una regla de negación `Read` también bloquea las [herramientas Edit y Write](/docs/es/errors#file-is-covered-by-a-read-deny-rule) en la misma ruta, incluyendo crear un archivo nuevo allí. NotebookEdit no está cubierto, así que agregue una regla de negación `Edit` para rutas que ninguna herramienta pueda cambiar. La verificación requiere Claude Code v2.1.208 o posterior en ediciones, y v2.1.228 o posterior en escrituras.370Una regla de negación `Read` también bloquea las herramientas [Edit y Write](/docs/es/errors#file-is-covered-by-a-read-deny-rule) en la misma ruta, incluida la creación de un nuevo archivo allí. NotebookEdit no está cubierto, por lo que agregue una regla de negación `Edit` para rutas que ninguna herramienta pueda cambiar. La verificación requiere Claude Code v2.1.208 o posterior en ediciones, y v2.1.228 o posterior en escrituras.

369 371 

370Claude Code verifica permisos de archivo solo contra reglas `Edit(path)` y `Read(path)`. Si escribe una regla de ruta para `Write`, `NotebookEdit`, `Glob` o la herramienta heredada `MultiEdit` en su lugar, Claude Code acepta la regla pero nunca la consulta, y [advierte al inicio](/docs/es/errors#is-not-matched-by-file-permission-checks), excepto para una regla `Glob` pasada en `--allowedTools`. Use `Edit(docs/**)` en lugar de `Write(docs/**)`, `NotebookEdit(docs/**)` o `MultiEdit(docs/**)`, y `Read(docs/**)` en lugar de `Glob(docs/**)`. Claude Code no advierte sobre una regla de nombre de herramienta sin ruta, como una regla de negación para `Write`; coincide esa regla a nivel de herramienta en todas partes. Requiere Claude Code v2.1.210 o posterior.372Claude Code verifica permisos de archivo solo contra reglas `Edit(path)` y `Read(path)`. Si escribe una regla de ruta para `Write`, `NotebookEdit`, `Glob` o la herramienta `MultiEdit` heredada en su lugar, Claude Code acepta la regla pero nunca la consulta, y [advierte al inicio](/docs/es/errors#is-not-matched-by-file-permission-checks), excepto para una regla `Glob` pasada en `--allowedTools`. Use `Edit(docs/**)` en lugar de `Write(docs/**)`, `NotebookEdit(docs/**)` o `MultiEdit(docs/**)`, y `Read(docs/**)` en lugar de `Glob(docs/**)`. Claude Code no advierte sobre una regla de nombre de herramienta sin ruta, como una regla de negación para `Write`; coincide esa regla a nivel de herramienta en todas partes. Requiere Claude Code v2.1.210 o posterior.

371 373 

372<Warning>374<Warning>

373 Las reglas de negación Read y Edit se aplican a las herramientas de archivo integradas de Claude, a comandos de archivo que Claude Code reconoce en Bash, como `cat`, `head`, `tail` y `sed`, y a los objetivos de [redirecciones](#redirections) de Bash como `> file` y `< file`. No se aplican a un comando que lee archivos sin nombrarlos, como `grep -r pattern .` ejecutado desde el directorio que contiene el archivo, o a subprocesos arbitrarios que leen o escriben archivos indirectamente, como un script de Python o Node que abre archivos por sí mismo. Para aplicación a nivel del SO que bloquea todos los procesos de acceder a una ruta, [habilite el sandbox](/docs/es/sandboxing).375 Las reglas de negación Read y Edit se aplican a las herramientas de archivo integradas de Claude, a comandos de archivo que Claude Code reconoce en Bash, como `cat`, `head`, `tail`, `sed` y `tee`, y a los destinos de [redirecciones](#redirections) de Bash como `> file` y `< file`. No se aplican a un comando que lee archivos sin nombrarlos, como `grep -r pattern .` ejecutado desde el directorio que contiene el archivo, o a subprocesos arbitrarios que leen o escriben archivos indirectamente, como un script de Python o Node que abre archivos por sí mismo. Para la aplicación a nivel del SO que bloquea todos los procesos de acceder a una ruta, [habilite el sandbox](/docs/es/sandboxing).

374</Warning>376</Warning>

375 377 

376Las reglas Read y Edit ambas usan sintaxis de patrón [gitignore](https://git-scm.com/docs/gitignore) con cuatro tipos de patrones distintos; para patrones de directorio de un solo segmento, la profundidad de coincidencia también depende del tipo de regla, descrito más adelante en esta sección:378Las reglas Read y Edit usan ambas sintaxis de patrón [gitignore](https://git-scm.com/docs/gitignore) con cuatro tipos de patrón distintos; para patrones de directorio de un solo segmento, la profundidad de coincidencia también depende del tipo de regla, descrito más adelante en esta sección:

377 379 

378| Patrón | Significado | Ejemplo | Coincide |380| Patrón | Significado | Ejemplo | Coincide |

379| ----------------- | --------------------------------------------------- | -------------------------------- | ---------------------------------------------------------------------------- |381| ----------------- | --------------------------------------------------- | -------------------------------- | ---------------------------------------------------------------------- |

380| `//path` | Ruta absoluta desde la raíz del sistema de archivos | `Read(//Users/alice/secrets/**)` | `/Users/alice/secrets/**` |382| `//path` | Ruta absoluta desde la raíz del sistema de archivos | `Read(//Users/alice/secrets/**)` | `/Users/alice/secrets/**` |

381| `~/path` | Ruta desde el directorio home | `Read(~/Documents/*.pdf)` | `/Users/alice/Documents/*.pdf` |383| `~/path` | Ruta desde el directorio de inicio | `Read(~/Documents/*.pdf)` | `/Users/alice/Documents/*.pdf` |

382| `/path` | Ruta relativa a la fuente de configuración | `Edit(/src/**/*.ts)` | `<directorio de trabajo principal>/src/**/*.ts` en configuración de proyecto |384| `/path` | Ruta relativa a la fuente de configuración | `Edit(/src/**/*.ts)` | `<primary working directory>/src/**/*.ts` en configuración de proyecto |

383| `path` o `./path` | Ruta relativa al directorio actual | `Read(*.env)` | `<cwd>/*.env` |385| `path` o `./path` | Ruta relativa al directorio actual | `Read(*.env)` | `<cwd>/*.env` |

384 386 

385<Warning>387<Warning>

386 Un patrón como `/Users/alice/file` no es una ruta absoluta. La barra diagonal inicial única se ancla en la fuente de configuración, no en la raíz del sistema de archivos. Use `//Users/alice/file` para rutas absolutas.388 Un patrón como `/Users/alice/file` no es una ruta absoluta. La barra inclinada inicial única se ancla en la fuente de configuración, no en la raíz del sistema de archivos. Use `//Users/alice/file` para rutas absolutas.

387</Warning>389</Warning>

388 390 

389Un patrón `/path` se ancla en un directorio asociado con la fuente de configuración que lo define, por lo que la misma regla coincide con diferentes ubicaciones dependiendo de dónde la coloque:391Un patrón `/path` se ancla en un directorio asociado con la fuente de configuración que lo define, por lo que la misma regla coincide con ubicaciones diferentes dependiendo de dónde la coloque:

390 392 

391| Regla definida en | `/path` se resuelve a |393| Regla definida en | `/path` se resuelve a |

392| :---------------------------------------------------- | :--------------------------------------- |394| :---------------------------------------------------- | :--------------------------------- |

393| Configuración de proyecto en `.claude/settings.json` | `<directorio de trabajo principal>/path` |395| Configuración de proyecto en `.claude/settings.json` | `<primary working directory>/path` |

394| Configuración local en `.claude/settings.local.json` | `<directorio de trabajo principal>/path` |396| Configuración local en `.claude/settings.local.json` | `<primary working directory>/path` |

395| Configuración de usuario en `~/.claude/settings.json` | `~/.claude/path` |397| Configuración de usuario en `~/.claude/settings.json` | `~/.claude/path` |

396| Un archivo pasado con `--settings <file>` | `<directorio del archivo>/path` |398| Un archivo pasado con `--settings <file>` | `<directory of file>/path` |

397| Banderas CLI o reglas de sesión | `<directorio de trabajo principal>/path` |399| Banderas CLI o reglas de sesión | `<primary working directory>/path` |

398 400 

399Una regla que agrega a través de `/permissions` sigue la fila para el archivo de configuración en el que la guarda.401Una regla que agrega a través de `/permissions` sigue la fila para el archivo de configuración en el que la guarda.

400 402 

401Las reglas de configuración local se anclan en el [directorio de trabajo principal](#working-directories) de la sesión, no en la raíz del repositorio donde Claude Code [almacena el archivo](#permission-system) en v2.1.211 y posterior. En una sesión iniciada en la raíz del repositorio, los dos directorios son iguales; en una sesión de [worktree](/docs/es/worktrees), una regla compartida como `Edit(/src/**)` coincide con el directorio `src/` propio de ese worktree.403Las reglas de configuración local se anclan en el [directorio de trabajo principal](#working-directories) de la sesión, no en la raíz del repositorio donde Claude Code [almacena el archivo](#permission-system) en v2.1.211 y posterior. En una sesión iniciada en la raíz del repositorio, los dos directorios son iguales; en una sesión de [worktree](/docs/es/worktrees), una regla compartida como `Edit(/src/**)` coincide con el directorio `src/` propio de ese worktree.

402 404 

403Una regla de negación como `Read(/secrets/**)` en configuración de usuario bloquea `~/.claude/secrets/**`, no un directorio `secrets` en su proyecto. Para escribir una regla en configuración de usuario que se aplique dentro de cada proyecto, use una ruta absoluta `//` o una ruta relativa a home `~/` en su lugar.405Una regla de negación como `Read(/secrets/**)` en configuración de usuario bloquea `~/.claude/secrets/**`, no un directorio `secrets` en su proyecto. Para escribir una regla en configuración de usuario que se aplique dentro de cada proyecto, use una ruta `//` absoluta o una ruta `~/` relativa a inicio en su lugar.

404 406 

405En Windows, las rutas se normalizan a forma POSIX antes de coincidir. `C:\Users\alice` se convierte en `/c/Users/alice`, así que use `//c/**/.env` para coincidir con archivos `.env` en cualquier lugar de esa unidad. Para coincidir en todas las unidades, use `//**/.env`.407En Windows, las rutas se normalizan a forma POSIX antes de coincidir. `C:\Users\alice` se convierte en `/c/Users/alice`, por lo que use `//c/**/.env` para coincidir con archivos `.env` en cualquier lugar de esa unidad. Para coincidir en todas las unidades, use `//**/.env`.

406 408 

407Ejemplos:409Ejemplos:

408 410 

409* `Edit(/docs/**)`: edita en `<directorio de trabajo principal>/docs/`, no `/docs/` o `<directorio de trabajo principal>/.claude/docs/`411* `Edit(/docs/**)`: ediciones en `<primary working directory>/docs/`, no `/docs/` o `<primary working directory>/.claude/docs/`

410* `Read(~/.zshrc)`: lee el `.zshrc` de su directorio home412* `Read(~/.zshrc)`: lee el `.zshrc` de su directorio de inicio

411* `Edit(//tmp/scratch.txt)`: edita la ruta absoluta `/tmp/scratch.txt`413* `Edit(//tmp/scratch.txt)`: edita la ruta absoluta `/tmp/scratch.txt`

412* `Read(src/**)`: como regla de permiso, lee desde `<directorio-actual>/src/` solamente; como regla de negación o solicitud, coincide con un directorio `src` a cualquier profundidad bajo el directorio actual414* `Read(src/**)`: como regla de permiso, lee desde `<current-directory>/src/` solo; como regla de negación o solicitud, coincide con un directorio `src` a cualquier profundidad bajo el directorio actual

413 415 

414Una regla solo coincide con archivos bajo su anclaje; dentro de ese límite, la profundidad de coincidencia depende de la forma del patrón y, para patrones de directorio de un solo segmento, el tipo de regla, descrito a continuación. Los nombres de archivo desnudos siguen la semántica de gitignore y coinciden a cualquier profundidad, por lo que `Read(.env)` y `Read(**/.env)` son equivalentes:416Una regla solo coincide con archivos bajo su ancla; dentro de ese límite, la profundidad de coincidencia depende de la forma del patrón y, para patrones de directorio de un solo segmento, del tipo de regla, descrito a continuación. Los nombres de archivo desnudos siguen la semántica de gitignore y coinciden a cualquier profundidad, por lo que `Read(.env)` y `Read(**/.env)` son equivalentes:

415 417 

416| Regla de negación | Bloquea | No bloquea |418| Regla de negación | Bloquea | No bloquea |

417| ------------------------------ | ----------------------------------------------------------- | -------------------------------------------------------------- |419| ------------------------------ | ----------------------------------------------------------- | ---------------------------------------------------------- |

418| `Read(.env)` o `Read(**/.env)` | cualquier `.env` en o bajo el directorio actual | `.env` en un directorio padre u otro proyecto |420| `Read(.env)` o `Read(**/.env)` | cualquier `.env` en o bajo el directorio actual | `.env` en un directorio padre u otro proyecto |

419| `Read(//**/.env)` | cualquier `.env` en cualquier lugar del sistema de archivos | nada; la regla está anclada en la raíz del sistema de archivos |421| `Read(//**/.env)` | cualquier `.env` en cualquier lugar del sistema de archivos | nada; la regla se ancla en la raíz del sistema de archivos |

420 422 

421Un patrón relativo con un solo segmento de directorio, como `src/**`, coincide a diferentes profundidades dependiendo del tipo de regla:423Un patrón relativo con un segmento de directorio único, como `src/**`, coincide a diferentes profundidades dependiendo del tipo de regla:

422 424 

423* **Reglas de permiso**: `Edit(src/**)` coincide solo con `<cwd>/src` y los archivos bajo él. Para permitir un nombre de directorio a cualquier profundidad, escriba `Edit(**/src/**)`.425* **Reglas de permiso**: `Edit(src/**)` coincide solo con `<cwd>/src` y los archivos bajo él. Para permitir un nombre de directorio a cualquier profundidad, escriba `Edit(**/src/**)`.

424* **Reglas de negación y solicitud**: `Read(secrets/**)` coincide con un directorio llamado `secrets` a cualquier profundidad bajo el directorio actual, por lo que la regla también se aplica a copias anidadas.426* **Reglas de negación y solicitud**: `Read(secrets/**)` coincide con un directorio llamado `secrets` a cualquier profundidad bajo el directorio actual, por lo que la regla también se aplica a copias anidadas.

428El siguiente ejemplo muestra cada forma de patrón contra un proyecto con un directorio `src/` de nivel superior y una copia anidada bajo `vendor/`:430El siguiente ejemplo muestra cada forma de patrón contra un proyecto con un directorio `src/` de nivel superior y una copia anidada bajo `vendor/`:

429 431 

430```text theme={null}432```text theme={null}

431<directorio-actual>/433<current-directory>/

432├── src/434├── src/

433│ └── app.ts435│ └── app.ts

434└── vendor/436└── vendor/

445| `Edit(**/src/**)` en cualquier tipo de regla | Sí | Sí |447| `Edit(**/src/**)` en cualquier tipo de regla | Sí | Sí |

446 448 

447<Note>449<Note>

448 En patrones gitignore, `*` coincide dentro de un solo segmento de ruta y puede aparecer en cualquier posición en el patrón, mientras que `**` coincide en directorios.450 En patrones de gitignore, `*` coincide dentro de un segmento de ruta único y puede aparecer en cualquier posición en el patrón, mientras que `**` coincide en directorios.

449</Note>451</Note>

450 452 

451Cuando aprueba una ruta de archivo con "Sí, no preguntar de nuevo", Claude Code escapa caracteres de patrón gitignore en esa ruta, como `[`, `]` y `*`, por lo que la regla generada coincide solo con la ruta literal que aprobó. Las reglas que escribe usted mismo no se escapan. Antes de v2.1.202, Claude Code guardaba la ruta sin escapar, por lo que una regla generada para un directorio llamado `[2024-06] Reports` podría fallar en coincidir con su propia ruta o coincidir con directorios hermanos no deseados.453Cuando aprueba una ruta de archivo con "Sí, y no vuelvas a preguntar", Claude Code escapa caracteres de patrón de gitignore en esa ruta, como `[`, `]` y `*`, por lo que la regla generada coincide solo con la ruta literal que aprobó. Las reglas que escribe usted mismo no se escapan. Antes de v2.1.202, Claude Code guardaba la ruta sin escapar, por lo que una regla generada para un directorio llamado `[2024-06] Reports` podría no coincidir con su propia ruta o coincidir con directorios hermanos no deseados.

452 454 

453No necesita escapar paréntesis en una ruta, por lo que `Edit(./Finance (2024)/**)` coincide con la carpeta `Finance (2024)` tal como está escrita.455No necesita escapar paréntesis en una ruta, por lo que `Edit(./Finance (2024)/**)` coincide con la carpeta `Finance (2024)` tal como está escrita.

454 456 

455Una regla de negación o solicitud cuya ruta no es utilizable como patrón gitignore aún protege esa ruta exacta. Una regla de permiso con un patrón no utilizable no aprueba nada.457Una regla de negación o solicitud cuya ruta no es utilizable como patrón de gitignore aún protege esa ruta exacta. Una regla de permiso con un patrón no utilizable no aprueba nada.

458 

459Un patrón de negación o solicitud que comienza con `!` es una negación de gitignore. Extrae las rutas que coincide de las reglas `path` o `./path` enumeradas antes. En la lista `deny` de un archivo de configuración, `Read(*.env)` seguido de `Read(!sample.env)` bloquea cada archivo cuyo nombre termina en `.env` a cualquier profundidad, excepto archivos nombrados `sample.env`. Una regla `!` enumerada primero no extrae nada.

460 

461La extracción solo alcanza reglas de la misma fuente. Un `Read(!.env)` en configuración de proyecto o en `--disallowedTools` no cancela un `Read(./.env)` de negación de configuración administrada o cualquier otro archivo de configuración.

456 462 

457Cuando Claude accede a un symlink, las reglas de permisos verifican dos rutas: el symlink mismo y el archivo al que se resuelve. Las reglas de permiso y negación tratan ese par de manera diferente: las reglas de permiso recurren a solicitarle, mientras que las reglas de negación bloquean directamente.463Dos límites estrechan lo que un patrón `!` puede extraer:

458 464 

459* **Reglas de permiso**: se aplican solo cuando tanto la ruta del symlink como su destino coinciden. Un symlink dentro de un directorio permitido que apunta fuera de él aún le solicita.465* Claude Code lee un patrón `!` relativo al directorio actual incluso cuando `/`, `~/` o `//` sigue a `!`, por lo que el patrón no puede alcanzar una regla anclada con uno de esos prefijos. `Read(!~/notes/public/**)` no extrae nada de `Read(~/notes/**)`.

460* **Reglas de negación**: se aplican cuando la ruta del symlink o su destino coincide. Un symlink que apunta a un archivo denegado está denegado. Por ejemplo, con `Read(./project/**)` permitido y `Read(~/.ssh/**)` denegado, un symlink en `./project/key` que apunta a `~/.ssh/id_rsa` está bloqueado: el destino falla la regla de permiso y coincide con la regla de negación.466* Una extracción no puede reabrir un archivo dentro de un directorio que una regla bloquea como un todo. Con `Read(secrets/**)` y `Read(!secrets/public/**)`, Claude Code aún bloquea `secrets/public` junto con el resto de `secrets`.

467 

468Cuando Claude accede a un symlink, las reglas de permiso verifican dos rutas: el symlink en sí y el archivo al que se resuelve. Las reglas de permiso y negación tratan ese par de manera diferente: las reglas de permiso vuelven a solicitar aprobación, mientras que las reglas de negación bloquean directamente.

469 

470* **Reglas de permiso**: se aplican solo cuando tanto la ruta del symlink como su destino coinciden. Un symlink dentro de un directorio permitido que apunta fuera de él aún le solicita aprobación.

471* **Reglas de negación**: se aplican cuando la ruta del symlink o su destino coincide. Un symlink que apunta a un archivo negado está negado en sí mismo. Por ejemplo, con `Read(./project/**)` permitido y `Read(~/.ssh/**)` negado, un symlink en `./project/key` que apunta a `~/.ssh/id_rsa` está bloqueado: el destino falla la regla de permiso y coincide con la regla de negación.

461 472 

462En macOS y Linux, una regla de negación o solicitud escrita a través de un directorio con symlink con un patrón `//`, `~/` o `/` también se aplica en la ubicación real del directorio. Por ejemplo, en macOS, donde `/etc` se resuelve a `/private/etc`, `Read(//etc/**)` también bloquea `/private/etc/hosts`. Antes de v2.1.268, una regla de negación o solicitud escrita a través de un directorio con symlink no se aplicaba a una ruta dada por su ubicación real.473En macOS y Linux, una regla de negación o solicitud escrita a través de un directorio con symlink con un patrón `//`, `~/` o `/` también se aplica en la ubicación real del directorio. Por ejemplo, en macOS, donde `/etc` se resuelve a `/private/etc`, `Read(//etc/**)` también bloquea `/private/etc/hosts`. Antes de v2.1.268, una regla de negación o solicitud escrita a través de un directorio con symlink no se aplicaba a una ruta dada por su ubicación real.

463 474 

464Cuando una herramienta abre un archivo aprobado, Claude Code [confirma que la ruta aún se resuelve a la ubicación que la verificación de permisos aprobó](/docs/es/errors#refusing-after-a-symlink-changed).475Cuando una herramienta abre un archivo aprobado, Claude Code [confirma que la ruta aún se resuelve a la ubicación que la verificación de permiso aprobó](/docs/es/errors#refusing-after-a-symlink-changed).

465 476 

466Grep y Glob buscan el directorio al que se resuelve el argumento `path`. Claude Code aplica reglas de negación `Read` a ese directorio.477Grep y Glob buscan el directorio al que se resuelve el argumento `path`. Claude Code aplica reglas de negación `Read` a ese directorio.

467 478 

469 WebFetch480 WebFetch

470</h3>481</h3>

471 482 

472Las reglas WebFetch usan un prefijo `domain:` y coinciden con el nombre de host de la URL solicitada. La coincidencia no distingue mayúsculas de minúsculas, admite comodines `*` y elimina un punto final de ambas la regla y el nombre de host para que `example.com.` y `example.com` se traten igual.483Las reglas de WebFetch usan un prefijo `domain:` y coinciden contra el nombre de host de la URL solicitada. La coincidencia no distingue mayúsculas de minúsculas, admite comodines `*` y elimina un `.` final de la regla y el nombre de host para que `example.com.` y `example.com` se traten igual.

473 484 

474* `WebFetch(domain:example.com)` coincide con solicitudes a `example.com`485* `WebFetch(domain:example.com)` coincide con solicitudes a `example.com`

475* `WebFetch(domain:*.example.com)` coincide con cualquier subdominio a cualquier profundidad, como `api.example.com` o `a.b.example.com`, pero no con `example.com` mismo486* `WebFetch(domain:*.example.com)` coincide con cualquier subdominio a cualquier profundidad, como `api.example.com` o `a.b.example.com`, pero no `example.com` en sí

476* `WebFetch(domain:*)` coincide con cada dominio. No es lo mismo que una regla `WebFetch` desnuda; vea [Permitir o negar cada búsqueda](#allow-or-deny-every-fetch)487* `WebFetch(domain:*)` coincide con cada dominio. No es lo mismo que una regla `WebFetch` desnuda; vea [Allow or deny every fetch](#allow-or-deny-every-fetch)

477 488 

478En cualquier posición que no sea un `*.` inicial o un `*` desnudo, el comodín coincide solo con el texto entre dos puntos. `WebFetch(domain:example.*)` coincide con `example.org`, donde `*` se convierte en `org`, pero no con `example.evil.com`, donde `*` tendría que convertirse en `evil.com` y cruzar un punto. Esto evita que un comodín final coincida con dominios que un atacante podría registrar.489En cualquier posición que no sea un `*.` inicial o un `*` desnudo, el comodín coincide solo con el texto entre dos puntos. `WebFetch(domain:example.*)` coincide con `example.org`, donde `*` se convierte en `org`, pero no `example.evil.com`, donde `*` tendría que convertirse en `evil.com` y cruzar un punto. Esto evita que un comodín final coincida con dominios que un atacante podría registrar.

479 490 

480Los comodines en reglas `WebFetch` requieren Claude Code v2.1.172 o posterior para coincidir con búsquedas.491Los comodines en reglas `WebFetch` requieren Claude Code v2.1.172 o posterior para coincidir con búsquedas.

481 492 

483 Permitir o negar cada búsqueda494 Permitir o negar cada búsqueda

484</h4>495</h4>

485 496 

486Una regla `WebFetch` desnuda es el nombre de la herramienta sin una parte `domain:`, como `"deny": ["WebFetch"]`. Tanto ella como `WebFetch(domain:*)` cubren cada URL, pero Claude Code las aplica de manera diferente, y solo la forma `domain:` también agrega su dominio a la [lista de dominios permitidos o denegados](/docs/es/sandboxing#network-isolation) del sandbox. Esa sección enumera las formas de comodín que el sandbox honra y la versión que agregó `*` desnudo.497Una regla `WebFetch` desnuda es el nombre de la herramienta sin una parte `domain:`, como `"deny": ["WebFetch"]`. Tanto ella como `WebFetch(domain:*)` cubren cada URL, pero Claude Code las aplica de manera diferente, y solo la forma `domain:` también agrega su dominio a la [lista de dominios permitidos o negados](/docs/es/sandboxing#network-isolation) del sandbox. Esa sección enumera las formas de comodín que el sandbox honra y la versión que agregó `*` desnudo.

487 498 

488Cada fila muestra qué hace una regla en la lista `allow` y en la lista `deny`:499Cada fila muestra qué hace una regla en la lista `allow` y en la lista `deny`:

489 500 

490| Regla | En `allow` | En `deny` |501| Regla | En `allow` | En `deny` |

491| :------------------- | :---------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------- |502| :------------------- | :---------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------- |

492| `WebFetch` | Claude busca sin solicitarle. No cambia qué hosts pueden alcanzar los comandos sandboxed. | Claude Code elimina la herramienta `WebFetch`, por lo que Claude no puede buscar en absoluto. No cambia qué hosts pueden alcanzar los comandos sandboxed. |503| `WebFetch` | Claude busca sin solicitarle aprobación. No cambia qué hosts pueden alcanzar los comandos en sandbox. | Claude Code elimina la herramienta `WebFetch`, por lo que Claude no puede buscar en absoluto. No cambia qué hosts pueden alcanzar los comandos en sandbox. |

493| `WebFetch(domain:*)` | Claude busca sin solicitarle, y los comandos sandboxed pueden alcanzar cualquier host. | Claude Code mantiene la herramienta y rechaza cada búsqueda, y los comandos sandboxed no pueden alcanzar ningún host. |504| `WebFetch(domain:*)` | Claude busca sin solicitarle aprobación, y los comandos en sandbox pueden alcanzar cualquier host. | Claude Code mantiene la herramienta y rechaza cada búsqueda, y los comandos en sandbox no pueden alcanzar ningún host. |

494 505 

495Las dos formas también difieren en lecturas de [artefactos](/docs/es/artifacts), las páginas que la herramienta Artifact publica en claude.ai. Una regla `WebFetch` desnuda de negación o solicitud no se aplica a esas lecturas. Una regla `domain:` que cubre `claude.ai` o el host de contenido `*.claudeusercontent.com`, como `WebFetch(domain:claude.ai)` o `WebFetch(domain:*)`, niega cada lectura o solicita antes de ella. Una regla [`Artifact`](/docs/es/artifacts#disable-artifacts) hace lo mismo.506Las dos formas también difieren en lecturas de [artefactos](/docs/es/artifacts), las páginas que la herramienta Artifact publica en claude.ai. Una regla de negación o solicitud `WebFetch` desnuda no se aplica a esas lecturas. Una regla `domain:` que cubre `claude.ai` o el host de contenido `*.claudeusercontent.com`, como `WebFetch(domain:claude.ai)` o `WebFetch(domain:*)`, niega cada lectura o solicita aprobación antes. Una regla [`Artifact`](/docs/es/artifacts#disable-artifacts) hace lo mismo.

496 507 

497Cuando una regla bloquea una lectura, la negación nombra la regla. Antes de v2.1.268, una regla `WebFetch` desnuda de negación bloqueaba cada lectura de artefacto, y una regla de solicitud desnuda solicitaba antes de cada una.508Cuando una regla bloquea una lectura, la negación nombra la regla. Antes de v2.1.268, una regla de negación `WebFetch` desnuda bloqueaba cada lectura de artefacto, y una regla de solicitud desnuda solicitaba aprobación antes de cada una.

498 509 

499Para permitir que Claude busque libremente mientras mantiene la lista de permitidos del sandbox como está, use la forma desnuda. Este `settings.json` hace eso:510Para permitir que Claude busque libremente mientras mantiene la lista de permitidos del sandbox como está, use la forma desnuda. Este `settings.json` hace eso:

500 511 

506}517}

507```518```

508 519 

509Cuando le pide a Claude que busque una página, busca sin un aviso. Cuando le pide que ejecute un `curl` [sandboxed](/docs/es/sandboxing) contra un host fuera de la lista de permitidos del sandbox, Claude Code aún le solicita para ese host, o en [modo automático](/docs/es/permission-modes#eliminate-prompts-with-auto-mode) envía la solicitud al clasificador, porque la regla desnuda no agregó el host a la lista de permitidos.520Cuando le pide a Claude que busque una página, busca sin una solicitud. Cuando le pide que ejecute un `curl` [en sandbox](/docs/es/sandboxing) contra un host fuera de la lista de permitidos del sandbox, Claude Code aún le solicita aprobación para ese host, porque la regla desnuda no agregó el host a la lista de permitidos.

521 

522En [modo automático](/docs/es/permission-modes#eliminate-prompts-with-auto-mode), Claude en su lugar nombra el host en los [dominios permitidos por comando](/docs/es/sandboxing#per-command-allowed-domains-in-auto-mode) del comando para que el clasificador revise.

510 523 

511<h3 id="mcp">524<h3 id="mcp">

512 MCP525 MCP

513</h3>526</h3>

514 527 

515Las reglas MCP usan el nombre del servidor tal como se configura en Claude Code, opcionalmente seguido del nombre de una herramienta de ese servidor.528Las reglas de MCP usan el nombre del servidor tal como está configurado en Claude Code, opcionalmente seguido del nombre de una herramienta de ese servidor.

516 529 

517* `mcp__puppeteer` coincide con cualquier herramienta proporcionada por el servidor `puppeteer`530* `mcp__puppeteer` coincide con cualquier herramienta proporcionada por el servidor `puppeteer`

518* `mcp__puppeteer__*` usa sintaxis de comodín y también coincide con todas las herramientas del servidor `puppeteer`531* `mcp__puppeteer__*` usa sintaxis de comodín y también coincide con todas las herramientas del servidor `puppeteer`

519* `mcp__puppeteer__puppeteer_navigate` coincide con la herramienta `puppeteer_navigate` proporcionada por el servidor `puppeteer`532* `mcp__puppeteer__puppeteer_navigate` coincide con la herramienta `puppeteer_navigate` proporcionada por el servidor `puppeteer`

520 533 

521Si su organización ha establecido una herramienta de conector [claude.ai](/docs/es/mcp#organization-controls-on-connector-tools) en `ask` y esa configuración llega a Claude Code en su sesión, las reglas de permiso para esa herramienta no tienen efecto: Claude Code solicita en cada llamada, incluso en modos `auto` y `bypassPermissions`. En modo `dontAsk`, que nunca solicita, Claude Code niega la llamada en su lugar. Las herramientas de conectores que Claude Code obtiene por sí mismo aparecen como `mcp__claude_ai_<server>__<tool>`.534Si su organización ha establecido una herramienta de [conector claude.ai](/docs/es/mcp#organization-controls-on-connector-tools) en `ask` y esa configuración llega a Claude Code en su sesión, las reglas de permiso para esa herramienta no tienen efecto: Claude Code solicita aprobación en cada llamada, incluso en modos `auto` y `bypassPermissions`. En modo `dontAsk`, que nunca solicita aprobación, Claude Code niega la llamada en su lugar. Las herramientas de conectores que Claude Code obtiene por sí mismo aparecen como `mcp__claude_ai_<server>__<tool>`.

522 535 

523En una sesión de [Cowork](https://claude.com/docs/cowork/overview) en la aplicación Claude Desktop, Claude ejecuta comandos de shell a través de la herramienta `mcp__workspace__bash` de Cowork en lugar de la herramienta `Bash` integrada, y Cowork igualmente proporciona `mcp__workspace__web_fetch` para búsquedas web. Claude Code también aplica reglas de negación que nombran la herramienta completa `Bash` o `WebFetch` a estas herramientas de Cowork, por lo que una regla de negación `Bash` administrada detiene a Claude de ejecutar comandos de shell en Cowork. Cuando Claude Code bloquea tal llamada, el mensaje nombra la herramienta de Cowork: `Permission to use mcp__workspace__bash has been denied.` Las reglas de permiso no se transfieren: Claude Code nunca aplica una regla de permiso `Bash` a `mcp__workspace__bash`.536En una sesión de [Cowork](https://claude.com/docs/cowork/overview) en la aplicación Claude Desktop, Claude ejecuta comandos de shell a través de la herramienta `mcp__workspace__bash` de Cowork en lugar de la herramienta `Bash` integrada, y Cowork igualmente proporciona `mcp__workspace__web_fetch` para búsquedas web. Claude Code también aplica reglas de negación que nombran la herramienta `Bash` o `WebFetch` completa a estas herramientas de Cowork, por lo que una regla de negación `Bash` administrada detiene a Claude de ejecutar comandos de shell en Cowork. Cuando Claude Code bloquea tal llamada, el mensaje nombra la herramienta de Cowork: `Permission to use mcp__workspace__bash has been denied.` Las reglas de permiso no se transfieren: Claude Code nunca aplica una regla de permiso `Bash` a `mcp__workspace__bash`.

524 537 

525<h3 id="agent-subagents">538<h3 id="agent-subagents">

526 Agent (subagentes)539 Agent (subagentes)

546 Cd559 Cd

547</h3>560</h3>

548 561 

549Las reglas `Cd` controlan a qué directorios el comando [`/cd`](/docs/es/commands) puede mover la sesión. `Cd` no es una herramienta invocable por el modelo: Claude no puede llamarla, y las reglas se aplican solo cuando ejecuta `/cd` usted mismo.562Las reglas `Cd` controlan a qué directorios el comando [`/cd`](/docs/es/commands) puede mover la sesión. `Cd` no es una herramienta invocable por modelo: Claude no puede llamarla, y las reglas se aplican solo cuando ejecuta `/cd` usted mismo.

550 563 

551Una regla de negación `Cd` desnuda deshabilita `/cd` completamente. Una regla de negación `Cd(<path-pattern>)` bloquea objetivos coincidentes. Las reglas de negación verifican cada ortografía del objetivo, incluyendo cada salto de symlink que resuelve, por lo que una regla escrita para una ruta también bloquea objetivos que se resuelven a ella.564Una regla de negación `Cd` desnuda deshabilita `/cd` completamente. Una regla de negación `Cd(<path-pattern>)` bloquea destinos coincidentes. Las reglas de negación verifican cada ortografía del destino, incluido cada salto de symlink que se resuelve, por lo que una regla escrita para una ruta también bloquea destinos que se resuelven a ella.

552 565 

553Agregar cualquier regla de permiso `Cd` cambia `/cd` al modo de lista de permitidos: el directorio objetivo resuelto debe coincidir con una de sus reglas de permiso, o `/cd` se niega. Sin reglas `Cd` configuradas, `/cd` mantiene su comportamiento predeterminado y le solicita confiar en un directorio desconocido.566Agregar cualquier regla de permiso `Cd` cambia `/cd` a modo de lista de permitidos: el directorio de destino resuelto debe coincidir con una de sus reglas de permiso, o `/cd` rechaza. Sin reglas `Cd` configuradas, `/cd` mantiene su comportamiento predeterminado y le solicita que confíe en un directorio desconocido.

554 567 

555Los patrones de ruta comparten los anclajes `//`, `~/` y `/` de [reglas Read y Edit](#read-and-edit), pero la coincidencia está anclada a la ruta del directorio completo en lugar de estilo gitignore. `*` coincide exactamente con un segmento de ruta y `**` coincide en segmentos. Un `/**` final también coincide con su raíz nombrada.568Los patrones de ruta comparten los anclajes `//`, `~/` y `/` de [reglas Read y Edit](#read-and-edit), pero la coincidencia se ancla a la ruta de directorio completa en lugar de estilo gitignore. `*` coincide exactamente con un segmento de ruta y `**` coincide en segmentos. Un `/**` final también coincide con su raíz nombrada.

556 569 

557| Regla | Coincide | No coincide |570| Regla | Coincide | No coincide |

558| --------------------- | ------------------------------------------------------------------------------------- | ----------------------------- |571| --------------------- | ------------------------------------------------------------------------------------- | ----------------------------- |

646Los permisos y el [sandboxing](/docs/es/sandboxing) son capas de seguridad complementarias:659Los permisos y el [sandboxing](/docs/es/sandboxing) son capas de seguridad complementarias:

647 660 

648* **Permisos** controlan qué herramientas puede usar Claude Code y qué archivos o dominios puede acceder. Se aplican a Bash, Read, Edit, WebFetch, MCP y todas las demás herramientas, excepto que una regla de negación o ask no puede bloquear [`EndConversation`](/docs/es/tools-reference#endconversation-tool-behavior) mientras cualquier otra herramienta permanezca.661* **Permisos** controlan qué herramientas puede usar Claude Code y qué archivos o dominios puede acceder. Se aplican a Bash, Read, Edit, WebFetch, MCP y todas las demás herramientas, excepto que una regla de negación o ask no puede bloquear [`EndConversation`](/docs/es/tools-reference#endconversation-tool-behavior) mientras cualquier otra herramienta permanezca.

649* **Sandboxing** proporciona aplicación a nivel del SO que restringe el acceso del sistema de archivos y red de la herramienta Bash. Se aplica solo a comandos Bash y sus procesos secundarios.662* **Sandboxing** proporciona aplicación a nivel del SO que restringe el acceso del sistema de archivos y red de los comandos Bash, PowerShell y [Monitor](/docs/es/tools-reference#monitor-tool) y sus procesos secundarios.

650 663 

651Use ambos para defensa en profundidad, ya que las restricciones de sandbox aún se aplican incluso si una inyección de solicitud omite la toma de decisiones de Claude. Las rutas y dominios de la configuración de sandbox y las reglas de permisos se [fusionan en la configuración final del sandbox](/docs/es/sandboxing#permission-rules).664Use ambos para defensa en profundidad, ya que las restricciones de sandbox aún se aplican incluso si una inyección de solicitud omite la toma de decisiones de Claude. Las rutas y dominios de la configuración de sandbox y las reglas de permisos se [fusionan en la configuración final del sandbox](/docs/es/sandboxing#permission-rules).

652 665