Documentation — Spybara

agent-sdk/mcp.md +1 −1

Details

309 </Tab>309 </Tab>

310</Tabs>310</Tabs>

311 311

312Para HTTP (sin transmisión), use `"type": "http"` en su lugar.312Para el transporte HTTP transmisible, use `"type": "http"` en su lugar. En `.mcp.json` y otros archivos de configuración JSON, `"streamable-http"` se acepta como un alias para `"http"`. La opción programática `mcpServers` acepta solo `"http"`.

313 313

314### Servidores MCP SDK314### Servidores MCP SDK

315 315

agent-sdk/python.md +4 −2

Details

2315 2315

2316**Nombre de herramienta:** `AskUserQuestion`2316**Nombre de herramienta:** `AskUserQuestion`

2317 2317

2318Hace preguntas aclaratorias al usuario durante la ejecución. Ver [Handle approvals and user input](/es/agent-sdk/user-input#handle-clarifying-questions) para detalles de uso.2318Hace preguntas aclaratorias al usuario durante la ejecución. Ver [Manejar aprobaciones e entrada del usuario](/es/agent-sdk/user-input#handle-clarifying-questions) para detalles de uso.

2319 2319

2320**Entrada:**2320**Entrada:**

2321 2321

2334 "multiSelect": bool, # Set to true to allow multiple selections2334 "multiSelect": bool, # Set to true to allow multiple selections

2335 }2335 }

2336 ],2336 ],

2337 "answers": dict | None, # User answers populated by the permission system2337 "answers": dict[str, str | list[str]] | None,

2338 # User answers populated by the permission system. Multi-select

2339 # answers may be a list of labels or a comma-joined string

2338}2340}

2339```2341```

2340 2342

agent-sdk/typescript.md +83 −1

Details

268 268

269Devuelve [`SDKSessionInfo`](#sdksessioninfo), o `undefined` si la sesión no se encuentra.269Devuelve [`SDKSessionInfo`](#return-type-sdksessioninfo), o `undefined` si la sesión no se encuentra.

270 270

271### `renameSession()`271### `renameSession()`

272 272

310 310

311### `resolveSettings()`

312

313Resuelve la configuración efectiva de Claude Code para un directorio determinado utilizando el mismo motor de fusión que la CLI, sin generar la CLI de Claude. Úselo para inspeccionar qué configuración vería una llamada a `query()` antes de invocar una.

314

315<Note>

316 Esta función es alfa y su API puede cambiar antes de la estabilización. Lee fuentes MDM, incluidas plist de macOS y HKLM/HKCU de Windows, para paridad con el inicio de la CLI, pero no ejecuta el subproceso `policyHelper` configurado por el administrador. El campo `permissions.defaultMode` se devuelve tal como está de todos los niveles, incluida la configuración del proyecto. El filtro de confianza que la CLI aplica antes de honrar los modos de permiso escalonados no se aplica.

317</Note>

318

319```typescript theme={null}

320function resolveSettings(

321 options?: ResolveSettingsOptions

322): Promise<ResolvedSettings>;

323```

324

325#### Parámetros

326

327`resolveSettings()` acepta un único objeto de opciones. Todos los campos son opcionales.

328

330| :------------------------------ | :------------------------------------ | :---------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

332| `options.settingSources` | [`SettingSource`](#settingsource)`[]` | Todas las fuentes | Qué fuentes del sistema de archivos cargar. Pase `[]` para omitir la configuración del usuario, proyecto y local. La configuración de políticas administradas se carga en todos los casos |

333| `options.managedSettings` | `Settings` | `undefined` | Configuración de política restrictiva fusionada en el nivel de precedencia de política administrada. Las claves no restrictivas como `model` se descartan silenciosamente |

335

336#### Tipo de retorno: `ResolvedSettings`

337

338`resolveSettings()` devuelve un objeto que describe la configuración fusionada y la fuente que contribuyó a cada clave.

339

340| Propiedad | Tipo | Descripción |

341| :----------- | :-------------------------------------------------- | :----------------------------------------------------------------------------------------------- |

342| `effective` | `Settings` | Configuración fusionada después de aplicar todas las fuentes habilitadas en orden de precedencia |

343| `provenance` | `Partial<Record<keyof Settings, ProvenanceEntry>>` | Para cada clave de nivel superior en `effective`, qué fuente suministró el valor |

344| `sources` | `Array<{ source, settings, path?, policyOrigin? }>` | Configuración sin procesar por fuente, ordenada de precedencia más baja a más alta |

345

346#### Ejemplo

347

348El ejemplo a continuación resuelve la configuración para un directorio de proyecto e imprime la fuente que controla el período de limpieza.

349

350```typescript theme={null}

351import { resolveSettings } from "@anthropic-ai/claude-agent-sdk";

352

353const { effective, provenance } = await resolveSettings({

354 cwd: "/path/to/project",

355 settingSources: ["user", "project", "local"],

356});

357

358console.log(`Cleanup period: ${effective.cleanupPeriodDays} days`);

359console.log(`Set by: ${provenance.cleanupPeriodDays?.source}`);

360```

361

311## Tipos362## Tipos

312 363

313### `Options`364### `Options`

864 | SDKFilesPersistedEvent915 | SDKFilesPersistedEvent

865 | SDKToolUseSummaryMessage916 | SDKToolUseSummaryMessage

866 | SDKRateLimitEvent917 | SDKRateLimitEvent

918 | SDKPermissionDeniedMessage

867 | SDKPromptSuggestionMessage;919 | SDKPromptSuggestionMessage;

868```920```

869 921

1052};1104};

1053```1105```

1054 1106

1107### `SDKPermissionDeniedMessage`

1108

1109Evento de transmisión emitido cuando el sistema de permisos deniega automáticamente una llamada de herramienta sin un aviso interactivo. Úselo para renderizar la denegación en su interfaz de usuario a medida que sucede, en lugar de solo observar el resultado de la herramienta `is_error` que sigue. La ruta de solicitud interactiva llega a su aplicación por separado a través de la devolución de llamada [`canUseTool`](#canusetool). Las denegaciones emitidas por un hook `PreToolUse` no se reportan a través de este evento.

1110

1111Este evento requiere Claude Code v2.1.136 o posterior.

1112

1113```typescript theme={null}

1114type SDKPermissionDeniedMessage = {

1115 type: "system";

1116 subtype: "permission_denied";

1117 tool_name: string;

1118 tool_use_id: string;

1119 agent_id?: string;

1120 decision_reason_type?: string;

1121 decision_reason?: string;

1122 message: string;

1123 uuid: UUID;

1124 session_id: string;

1125};

1126```

1127

1128| Campo | Tipo | Descripción |

1129| ---------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |

1130| `tool_name` | `string` | Nombre de la herramienta que fue denegada |

1131| `tool_use_id` | `string` | ID del bloque `tool_use` que esta denegación responde |

1132| `agent_id` | `string` | ID del subagente cuando la llamada denegada se originó dentro de un subagente. Refleja el campo en `can_use_tool` para enrutamiento del lado del host |

1133| `decision_reason_type` | `string` | Discriminador para el componente que decidió, como `"rule"`, `"mode"`, `"classifier"`, o `"asyncAgent"` |

1134| `decision_reason` | `string` | Razón legible por humanos del componente que decide, cuando está disponible |

1135| `message` | `string` | Mensaje de rechazo devuelto al modelo en el `tool_result` |

1136

1055### `SDKPermissionDenial`1137### `SDKPermissionDenial`

1056 1138

1057Información sobre un uso de herramienta denegado.1139Información sobre un uso de herramienta denegado.

agent-sdk/user-input.md +810 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Gestionar aprobaciones e entrada de usuario

7> Presente las solicitudes de aprobación y preguntas aclaratorias de Claude a los usuarios, luego devuelva sus decisiones al SDK.

9Mientras trabaja en una tarea, Claude a veces necesita consultar con los usuarios. Podría necesitar permiso antes de eliminar archivos, o necesitar preguntar qué base de datos usar para un nuevo proyecto. Su aplicación necesita presentar estas solicitudes a los usuarios para que Claude pueda continuar con su entrada.

11Claude solicita entrada del usuario en dos situaciones: cuando necesita **permiso para usar una herramienta** (como eliminar archivos o ejecutar comandos), y cuando tiene **preguntas aclaratorias** (a través de la herramienta `AskUserQuestion`). Ambas activan su callback `canUseTool`, que pausa la ejecución hasta que devuelva una respuesta. Esto es diferente de los turnos de conversación normales donde Claude termina y espera su próximo mensaje.

13Para preguntas aclaratorias, Claude genera las preguntas y opciones. Su función es presentarlas a los usuarios y devolver sus selecciones. No puede agregar sus propias preguntas a este flujo; si necesita preguntarle algo a los usuarios usted mismo, hágalo por separado en la lógica de su aplicación.

15El callback puede permanecer pendiente indefinidamente. La ejecución permanece pausada hasta que su callback regrese, y el SDK solo cancela la espera cuando la consulta misma se cancela. Si un usuario podría tardar más en responder de lo que su proceso puede razonablemente mantenerse ejecutando, el SDK de TypeScript admite el [`defer` hook decision](/es/hooks#defer-a-tool-call-for-later), que permite que el proceso salga y se reanude más tarde desde la sesión persistida; esta opción no está disponible en el SDK de Python.

17Esta guía le muestra cómo detectar cada tipo de solicitud y responder apropiadamente.

19## Detectar cuándo Claude necesita entrada

21Pase un callback `canUseTool` en sus opciones de consulta. El callback se activa cada vez que Claude necesita entrada del usuario, recibiendo el nombre de la herramienta y la entrada como argumentos:

23<CodeGroup>

24 ```python Python theme={null}

25 async def handle_tool_request(tool_name, input_data, context):

26 # Solicitar al usuario y devolver permitir o denegar

27 ...

30 options = ClaudeAgentOptions(can_use_tool=handle_tool_request)

31 ```

33 ```typescript TypeScript theme={null}

34 async function handleToolRequest(toolName, input, options) {

35 // options includes { signal: AbortSignal, suggestions?: PermissionUpdate[] }

36 // Solicitar al usuario y devolver permitir o denegar

37 }

39 const options = { canUseTool: handleToolRequest };

40 ```

41</CodeGroup>

43El callback se activa en dos casos:

451. **La herramienta necesita aprobación**: Claude quiere usar una herramienta que no está aprobada automáticamente por [reglas de permisos](/es/agent-sdk/permissions) o modos. Verifique `tool_name` para la herramienta (por ejemplo, `"Bash"`, `"Write"`).

462. **Claude hace una pregunta**: Claude llama a la herramienta `AskUserQuestion`. Verifique si `tool_name == "AskUserQuestion"` para manejarlo de manera diferente. Si especifica un array `tools`, incluya `AskUserQuestion` para que esto funcione. Vea [Manejar preguntas aclaratorias](#handle-clarifying-questions) para más detalles.

48<Note>

49 Para permitir o denegar automáticamente herramientas sin solicitar a los usuarios, use [hooks](/es/agent-sdk/hooks) en su lugar. Los hooks se ejecutan antes de `canUseTool` y pueden permitir, denegar o modificar solicitudes según su propia lógica. También puede usar el [`PermissionRequest` hook](/es/agent-sdk/hooks#available-hooks) para enviar notificaciones externas (Slack, correo electrónico, push) cuando Claude está esperando aprobación.

50</Note>

52## Manejar solicitudes de aprobación de herramientas

54Una vez que haya pasado un callback `canUseTool` en sus opciones de consulta, se activa cuando Claude quiere usar una herramienta que no está aprobada automáticamente. Su callback recibe tres argumentos:

56| Argumento | Descripción |

57| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

58| `toolName` | El nombre de la herramienta que Claude quiere usar (por ejemplo, `"Bash"`, `"Write"`, `"Edit"`) |

59| `input` | Los parámetros que Claude está pasando a la herramienta. El contenido varía según la herramienta. |

60| `options` (TS) / `context` (Python) | Contexto adicional incluyendo `suggestions` opcional (entradas `PermissionUpdate` propuestas para evitar re-solicitar) y una señal de cancelación. En TypeScript, `signal` es un `AbortSignal`; en Python, el campo de señal está reservado para uso futuro. Vea [`ToolPermissionContext`](/es/agent-sdk/python#toolpermissioncontext) para Python. |

62El objeto `input` contiene parámetros específicos de la herramienta. Ejemplos comunes:

64| Herramienta | Campos de entrada |

65| ----------- | --------------------------------------- |

66| `Bash` | `command`, `description`, `timeout` |

67| `Write` | `file_path`, `content` |

68| `Edit` | `file_path`, `old_string`, `new_string` |

69| `Read` | `file_path`, `offset`, `limit` |

71Vea la referencia del SDK para esquemas de entrada completos: [Python](/es/agent-sdk/python#tool-input%2Foutput-types) | [TypeScript](/es/agent-sdk/typescript#tool-input-types).

73Puede mostrar esta información al usuario para que pueda decidir si permitir o rechazar la acción, luego devolver la respuesta apropiada.

75El siguiente ejemplo le pide a Claude que cree y elimine un archivo de prueba. Cuando Claude intenta cada operación, el callback imprime la solicitud de herramienta en la terminal y solicita aprobación s/n.

77<CodeGroup>

78 ```python Python theme={null}

79 import asyncio

81 from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query

82 from claude_agent_sdk.types import (

83 HookMatcher,

84 PermissionResultAllow,

85 PermissionResultDeny,

86 ToolPermissionContext,

87 )

90 async def can_use_tool(

91 tool_name: str, input_data: dict, context: ToolPermissionContext

92 ) -> PermissionResultAllow | PermissionResultDeny:

93 # Mostrar la solicitud de herramienta

94 print(f"\nTool: {tool_name}")

95 if tool_name == "Bash":

96 print(f"Command: {input_data.get('command')}")

97 if input_data.get("description"):

98 print(f"Description: {input_data.get('description')}")

99 else:

100 print(f"Input: {input_data}")

101

102 # Obtener aprobación del usuario

103 response = input("Allow this action? (y/n): ")

104

105 # Devolver permitir o denegar según la respuesta del usuario

106 if response.lower() == "y":

107 # Permitir: la herramienta se ejecuta con la entrada original (o modificada)

108 return PermissionResultAllow(updated_input=input_data)

109 else:

110 # Denegar: la herramienta no se ejecuta, Claude ve el mensaje

111 return PermissionResultDeny(message="User denied this action")

112

113

114 # Solución requerida: hook ficticio mantiene el flujo abierto para can_use_tool

115 async def dummy_hook(input_data, tool_use_id, context):

116 return {"continue_": True}

117

118

119 async def prompt_stream():

120 yield {

121 "type": "user",

122 "message": {

123 "role": "user",

124 "content": "Create a test file in /tmp and then delete it",

125 },

126 }

127

128

129 async def main():

130 async for message in query(

131 prompt=prompt_stream(),

132 options=ClaudeAgentOptions(

133 can_use_tool=can_use_tool,

134 hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[dummy_hook])]},

135 ),

136 ):

137 if isinstance(message, ResultMessage) and message.subtype == "success":

138 print(message.result)

139

140

141 asyncio.run(main())

142 ```

143

144 ```typescript TypeScript theme={null}

145 import { query } from "@anthropic-ai/claude-agent-sdk";

146 import * as readline from "readline";

147

148 // Helper para solicitar entrada del usuario en la terminal

149 function prompt(question: string): Promise<string> {

150 const rl = readline.createInterface({

151 input: process.stdin,

152 output: process.stdout

153 });

154 return new Promise((resolve) =>

155 rl.question(question, (answer) => {

156 rl.close();

157 resolve(answer);

158 })

159 );

160 }

161

162 for await (const message of query({

163 prompt: "Create a test file in /tmp and then delete it",

164 options: {

165 canUseTool: async (toolName, input) => {

166 // Mostrar la solicitud de herramienta

167 console.log(`\nTool: ${toolName}`);

168 if (toolName === "Bash") {

169 console.log(`Command: ${input.command}`);

170 if (input.description) console.log(`Description: ${input.description}`);

171 } else {

172 console.log(`Input: ${JSON.stringify(input, null, 2)}`);

173 }

174

175 // Obtener aprobación del usuario

176 const response = await prompt("Allow this action? (y/n): ");

177

178 // Devolver permitir o denegar según la respuesta del usuario

179 if (response.toLowerCase() === "y") {

180 // Permitir: la herramienta se ejecuta con la entrada original (o modificada)

181 return { behavior: "allow", updatedInput: input };

182 } else {

183 // Denegar: la herramienta no se ejecuta, Claude ve el mensaje

184 return { behavior: "deny", message: "User denied this action" };

185 }

186 }

187 }

188 })) {

189 if ("result" in message) console.log(message.result);

190 }

191 ```

192</CodeGroup>

193

194<Note>

195 En Python, `can_use_tool` requiere [modo de flujo](/es/agent-sdk/streaming-vs-single-mode) y un hook `PreToolUse` que devuelva `{"continue_": True}` para mantener el flujo abierto. Sin este hook, el flujo se cierra antes de que se pueda invocar el callback de permiso.

196</Note>

197

198Este ejemplo usa un flujo s/n donde cualquier entrada que no sea `y` se trata como una denegación. En la práctica, podría construir una interfaz de usuario más rica que permita a los usuarios modificar la solicitud, proporcionar retroalimentación o redirigir a Claude completamente. Vea [Responder a solicitudes de herramientas](#respond-to-tool-requests) para todas las formas en que puede responder.

199

200### Responder a solicitudes de herramientas

201

202Su callback devuelve uno de dos tipos de respuesta:

203

204| Respuesta | Python | TypeScript |

205| ------------ | ------------------------------------------ | ------------------------------------- |

206| **Permitir** | `PermissionResultAllow(updated_input=...)` | `{ behavior: "allow", updatedInput }` |

207| **Denegar** | `PermissionResultDeny(message=...)` | `{ behavior: "deny", message }` |

208

209Al permitir, pase la entrada de la herramienta (original o modificada). Al denegar, proporcione un mensaje explicando por qué. Claude ve este mensaje y puede ajustar su enfoque.

210

211<CodeGroup>

212 ```python Python theme={null}

213 from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

214

215 # Permitir que la herramienta se ejecute

216 return PermissionResultAllow(updated_input=input_data)

217

218 # Bloquear la herramienta

219 return PermissionResultDeny(message="User rejected this action")

220 ```

221

222 ```typescript TypeScript theme={null}

223 // Permitir que la herramienta se ejecute

224 return { behavior: "allow", updatedInput: input };

225

226 // Bloquear la herramienta

227 return { behavior: "deny", message: "User rejected this action" };

228 ```

229</CodeGroup>

230

231Más allá de permitir o denegar, puede modificar la entrada de la herramienta o proporcionar contexto que ayude a Claude a ajustar su enfoque:

232

233* **Aprobar**: permitir que la herramienta se ejecute como Claude solicitó

234* **Aprobar con cambios**: modificar la entrada antes de la ejecución (por ejemplo, desinfectar rutas, agregar restricciones)

235* **Rechazar**: bloquear la herramienta y decirle a Claude por qué

236* **Sugerir alternativa**: bloquear pero guiar a Claude hacia lo que el usuario quiere en su lugar

237* **Redirigir completamente**: usar [entrada de flujo](/es/agent-sdk/streaming-vs-single-mode) para enviar a Claude una instrucción completamente nueva

238

239<Tabs>

240 <Tab title="Aprobar">

241 El usuario aprueba la acción tal como está. Pase la `input` de su callback sin cambios y la herramienta se ejecuta exactamente como Claude solicitó.

242

243 <CodeGroup>

244 ```python Python theme={null}

245 async def can_use_tool(tool_name, input_data, context):

246 print(f"Claude wants to use {tool_name}")

247 approved = await ask_user("Allow this action?")

248

249 if approved:

250 return PermissionResultAllow(updated_input=input_data)

251 return PermissionResultDeny(message="User declined")

252 ```

253

254 ```typescript TypeScript theme={null}

255 canUseTool: async (toolName, input) => {

256 console.log(`Claude wants to use ${toolName}`);

257 const approved = await askUser("Allow this action?");

258

259 if (approved) {

260 return { behavior: "allow", updatedInput: input };

261 }

262 return { behavior: "deny", message: "User declined" };

263 };

264 ```

265 </CodeGroup>

266 </Tab>

267

268 <Tab title="Aprobar con cambios">

269 El usuario aprueba pero quiere modificar la solicitud primero. Puede cambiar la entrada antes de que la herramienta se ejecute. Claude ve el resultado pero no se le dice que cambió nada. Útil para desinfectar parámetros, agregar restricciones o limitar el acceso.

270

271 <CodeGroup>

272 ```python Python theme={null}

273 async def can_use_tool(tool_name, input_data, context):

274 if tool_name == "Bash":

275 # Usuario aprobó, pero limita todos los comandos a sandbox

276 sandboxed_input = {**input_data}

277 sandboxed_input["command"] = input_data["command"].replace(

278 "/tmp", "/tmp/sandbox"

279 )

280 return PermissionResultAllow(updated_input=sandboxed_input)

281 return PermissionResultAllow(updated_input=input_data)

282 ```

283

284 ```typescript TypeScript theme={null}

285 canUseTool: async (toolName, input) => {

286 if (toolName === "Bash") {

287 // Usuario aprobó, pero limita todos los comandos a sandbox

288 const sandboxedInput = {

289 ...input,

290 command: input.command.replace("/tmp", "/tmp/sandbox")

291 };

292 return { behavior: "allow", updatedInput: sandboxedInput };

293 }

294 return { behavior: "allow", updatedInput: input };

295 };

296 ```

297 </CodeGroup>

298 </Tab>

299

300 <Tab title="Rechazar">

301 El usuario no quiere que esta acción suceda. Bloquee la herramienta y proporcione un mensaje explicando por qué. Claude ve este mensaje y puede intentar un enfoque diferente.

302

303 <CodeGroup>

304 ```python Python theme={null}

305 async def can_use_tool(tool_name, input_data, context):

306 approved = await ask_user(f"Allow {tool_name}?")

307

308 if not approved:

309 return PermissionResultDeny(message="User rejected this action")

310 return PermissionResultAllow(updated_input=input_data)

311 ```

312

313 ```typescript TypeScript theme={null}

314 canUseTool: async (toolName, input) => {

315 const approved = await askUser(`Allow ${toolName}?`);

316

317 if (!approved) {

318 return {

319 behavior: "deny",

320 message: "User rejected this action"

321 };

322 }

323 return { behavior: "allow", updatedInput: input };

324 };

325 ```

326 </CodeGroup>

327 </Tab>

328

329 <Tab title="Sugerir alternativa">

330 El usuario no quiere esta acción específica, pero tiene una idea diferente. Bloquee la herramienta e incluya orientación en su mensaje. Claude leerá esto y decidirá cómo proceder según su retroalimentación.

331

332 <CodeGroup>

333 ```python Python theme={null}

334 async def can_use_tool(tool_name, input_data, context):

335 if tool_name == "Bash" and "rm" in input_data.get("command", ""):

336 # El usuario no quiere eliminar, sugiera archivar en su lugar

337 return PermissionResultDeny(

338 message="User doesn't want to delete files. They asked if you could compress them into an archive instead."

339 )

340 return PermissionResultAllow(updated_input=input_data)

341 ```

342

343 ```typescript TypeScript theme={null}

344 canUseTool: async (toolName, input) => {

345 if (toolName === "Bash" && input.command.includes("rm")) {

346 // El usuario no quiere eliminar, sugiera archivar en su lugar

347 return {

348 behavior: "deny",

349 message:

350 "User doesn't want to delete files. They asked if you could compress them into an archive instead."

351 };

352 }

353 return { behavior: "allow", updatedInput: input };

354 };

355 ```

356 </CodeGroup>

357 </Tab>

358

359 <Tab title="Redirigir completamente">

360 Para un cambio de dirección completo (no solo un empujón), use [entrada de flujo](/es/agent-sdk/streaming-vs-single-mode) para enviar a Claude una nueva instrucción directamente. Esto evita la solicitud de herramienta actual y le da a Claude instrucciones completamente nuevas para seguir.

361 </Tab>

362</Tabs>

363

364## Manejar preguntas aclaratorias

365

366Cuando Claude necesita más dirección en una tarea con múltiples enfoques válidos, llama a la herramienta `AskUserQuestion`. Esto activa su callback `canUseTool` con `toolName` establecido en `AskUserQuestion`. La entrada contiene las preguntas de Claude como opciones de opción múltiple, que muestra al usuario y devuelve sus selecciones.

367

368<Tip>

369 Las preguntas aclaratorias son especialmente comunes en [`plan` mode](/es/agent-sdk/permissions#plan-mode-plan), donde Claude explora la base de código y hace preguntas antes de proponer un plan. Esto hace que el modo plan sea ideal para flujos de trabajo interactivos donde desea que Claude recopile requisitos antes de hacer cambios.

370</Tip>

371

372Los siguientes pasos muestran cómo manejar preguntas aclaratorias:

373

374<Steps>

375 <Step title="Pasar un callback canUseTool">

376 Pase un callback `canUseTool` en sus opciones de consulta. De forma predeterminada, `AskUserQuestion` está disponible. Si especifica un array `tools` para restringir las capacidades de Claude (por ejemplo, un agente de solo lectura con solo `Read`, `Glob` y `Grep`), incluya `AskUserQuestion` en ese array. De lo contrario, Claude no podrá hacer preguntas aclaratorias:

377

378 <CodeGroup>

379 ```python Python theme={null}

380 async for message in query(

381 prompt="Analyze this codebase",

382 options=ClaudeAgentOptions(

383 # Incluya AskUserQuestion en su lista de herramientas

384 tools=["Read", "Glob", "Grep", "AskUserQuestion"],

385 can_use_tool=can_use_tool,

386 ),

387 ):

388 print(message)

389 ```

390

391 ```typescript TypeScript theme={null}

392 for await (const message of query({

393 prompt: "Analyze this codebase",

394 options: {

395 // Incluya AskUserQuestion en su lista de herramientas

396 tools: ["Read", "Glob", "Grep", "AskUserQuestion"],

397 canUseTool: async (toolName, input) => {

398 // Manejar preguntas aclaratorias aquí

399 }

400 }

401 })) {

402 console.log(message);

403 }

404 ```

405 </CodeGroup>

406 </Step>

407

408 <Step title="Detectar AskUserQuestion">

409 En su callback, verifique si `toolName` es igual a `AskUserQuestion` para manejarlo de manera diferente a otras herramientas:

410

411 <CodeGroup>

412 ```python Python theme={null}

413 async def can_use_tool(tool_name: str, input_data: dict, context):

414 if tool_name == "AskUserQuestion":

415 # Su implementación para recopilar respuestas del usuario

416 return await handle_clarifying_questions(input_data)

417 # Manejar otras herramientas normalmente

418 return await prompt_for_approval(tool_name, input_data)

419 ```

420

421 ```typescript TypeScript theme={null}

422 canUseTool: async (toolName, input) => {

423 if (toolName === "AskUserQuestion") {

424 // Su implementación para recopilar respuestas del usuario

425 return handleClarifyingQuestions(input);

426 }

427 // Manejar otras herramientas normalmente

428 return promptForApproval(toolName, input);

429 };

430 ```

431 </CodeGroup>

432 </Step>

433

434 <Step title="Analizar la entrada de la pregunta">

435 La entrada contiene las preguntas de Claude en un array `questions`. Cada pregunta tiene una `question` (el texto a mostrar), `options` (las opciones) y `multiSelect` (si se permiten múltiples selecciones):

436

437 ```json theme={null}

438 {

439 "questions": [

440 {

441 "question": "How should I format the output?",

442 "header": "Format",

443 "options": [

444 { "label": "Summary", "description": "Brief overview" },

445 { "label": "Detailed", "description": "Full explanation" }

446 ],

447 "multiSelect": false

448 },

449 {

450 "question": "Which sections should I include?",

451 "header": "Sections",

452 "options": [

453 { "label": "Introduction", "description": "Opening context" },

454 { "label": "Conclusion", "description": "Final summary" }

455 ],

456 "multiSelect": true

457 }

458 ]

459 }

460 ```

461

462 Vea [Formato de pregunta](#question-format) para descripciones completas de campos.

463 </Step>

464

465 <Step title="Recopilar respuestas del usuario">

466 Presente las preguntas al usuario y recopile sus selecciones. Cómo lo hace depende de su aplicación: un indicador de terminal, un formulario web, un diálogo móvil, etc.

467 </Step>

468

469 <Step title="Devolver respuestas a Claude">

470 Construya el objeto `answers` como un registro donde cada clave es el texto `question` y cada valor es la `label` de la opción seleccionada:

471

472 | Del objeto de pregunta | Usar como |

473 | ------------------------------------------------------------------- | --------- |

474 | Campo `question` (por ejemplo, `"How should I format the output?"`) | Clave |

475 | Campo `label` de la opción seleccionada (por ejemplo, `"Summary"`) | Valor |

476

477 Para preguntas de selección múltiple, pase un array de etiquetas o únalas con `", "`. Si [admite entrada de texto libre](#support-free-text-input), use el texto personalizado del usuario como valor.

478

479 <CodeGroup>

480 ```python Python theme={null}

481 return PermissionResultAllow(

482 updated_input={

483 "questions": input_data.get("questions", []),

484 "answers": {

485 "How should I format the output?": "Summary",

486 "Which sections should I include?": ["Introduction", "Conclusion"],

487 },

488 }

489 )

490 ```

491

492 ```typescript TypeScript theme={null}

493 return {

494 behavior: "allow",

495 updatedInput: {

496 questions: input.questions,

497 answers: {

498 "How should I format the output?": "Summary",

499 "Which sections should I include?": "Introduction, Conclusion"

500 }

501 }

502 };

503 ```

504 </CodeGroup>

505 </Step>

506</Steps>

507

508### Formato de pregunta

509

510La entrada contiene las preguntas generadas por Claude en un array `questions`. Cada pregunta tiene estos campos:

511

512| Campo | Descripción |

513| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |

514| `question` | El texto completo de la pregunta a mostrar |

515| `header` | Etiqueta corta para la pregunta (máximo 12 caracteres) |

516| `options` | Array de 2-4 opciones, cada una con `label` y `description`. TypeScript: opcionalmente `preview` (vea [abajo](#option-previews-type-script)) |

517| `multiSelect` | Si es `true`, los usuarios pueden seleccionar múltiples opciones |

518

519La estructura que su callback recibe:

520

521```json theme={null}

522{

523 "questions": [

524 {

525 "question": "How should I format the output?",

526 "header": "Format",

527 "options": [

528 { "label": "Summary", "description": "Brief overview of key points" },

529 { "label": "Detailed", "description": "Full explanation with examples" }

530 ],

531 "multiSelect": false

532 }

533 ]

534}

535```

536

537#### Vistas previas de opciones (TypeScript)

538

539`toolConfig.askUserQuestion.previewFormat` agrega un campo `preview` a cada opción para que su aplicación pueda mostrar una maqueta visual junto a la etiqueta. Sin esta configuración, Claude no genera vistas previas y el campo está ausente.

540

541| `previewFormat` | `preview` contiene |

542| :------------------------------ | :------------------------------------------------------------------------------------------------------------------------ |

543| sin establecer (predeterminado) | El campo está ausente. Claude no genera vistas previas. |

544| `"markdown"` | Arte ASCII y bloques de código cercados |

545| `"html"` | Un fragmento `<div>` con estilo (el SDK rechaza `<script>`, `<style>` y `<!DOCTYPE>` antes de que su callback se ejecute) |

546

547El formato se aplica a todas las preguntas en la sesión. Claude incluye `preview` en opciones donde una comparación visual ayuda (opciones de diseño, esquemas de color) y la omite donde no lo haría (confirmaciones sí/no, opciones de solo texto). Verifique `undefined` antes de renderizar.

548

549```typescript theme={null}

550import { query } from "@anthropic-ai/claude-agent-sdk";

551

552for await (const message of query({

553 prompt: "Help me choose a card layout",

554 options: {

555 toolConfig: {

556 askUserQuestion: { previewFormat: "html" }

557 },

558 canUseTool: async (toolName, input) => {

559 // input.questions[].options[].preview es una cadena HTML o undefined

560 return { behavior: "allow", updatedInput: input };

561 }

562 }

563})) {

564 // ...

565}

566```

567

568Una opción con una vista previa HTML:

569

570```json theme={null}

571{

572 "label": "Compact",

573 "description": "Title and metric value only",

574 "preview": "<div style=\"padding:12px;border:1px solid #ddd;border-radius:8px\"><div style=\"font-size:12px;color:#666\">Active users</div><div style=\"font-size:28px;font-weight:600\">1,284</div></div>"

575}

576```

577

578### Formato de respuesta

579

580Devuelva un objeto `answers` que asigne cada campo `question` de la pregunta a la `label` de la opción seleccionada:

581

582| Campo | Descripción |

583| ----------- | --------------------------------------------------------------------------------------- |

584| `questions` | Pase el array de preguntas original (requerido para el procesamiento de herramientas) |

585| `answers` | Objeto donde las claves son texto de pregunta y los valores son etiquetas seleccionadas |

586

587Para preguntas de selección múltiple, pase un array de etiquetas o únalas con `", "`. Para entrada de texto libre, use el texto personalizado del usuario directamente.

588

589```json theme={null}

590{

591 "questions": [

592 // ...

593 ],

594 "answers": {

595 "How should I format the output?": "Summary",

596 "Which sections should I include?": ["Introduction", "Conclusion"]

597 }

598}

599```

600

601#### Admitir entrada de texto libre

602

603Las opciones predefinidas de Claude no siempre cubrirán lo que los usuarios quieren. Para permitir que los usuarios escriban su propia respuesta:

604

605* Muestre una opción "Otro" adicional después de las opciones de Claude que acepte entrada de texto

606* Use el texto personalizado del usuario como valor de respuesta (no la palabra "Otro")

607

608Vea el [ejemplo completo](#complete-example) a continuación para una implementación completa.

609

610### Ejemplo completo

611

612Claude hace preguntas aclaratorias cuando necesita entrada del usuario para proceder. Por ejemplo, cuando se le pide que ayude a decidir sobre una pila de tecnología para una aplicación móvil, Claude podría preguntar sobre multiplataforma vs nativo, preferencias de backend o plataformas objetivo. Estas preguntas ayudan a Claude a tomar decisiones que coincidan con las preferencias del usuario en lugar de adivinar.

613

614Este ejemplo maneja esas preguntas en una aplicación de terminal. Esto es lo que sucede en cada paso:

615

6161. **Enrutar la solicitud**: El callback `canUseTool` verifica si el nombre de la herramienta es `"AskUserQuestion"` y enruta a un manejador dedicado

6172. **Mostrar preguntas**: El manejador recorre el array `questions` e imprime cada pregunta con opciones numeradas

6183. **Recopilar entrada**: El usuario puede ingresar un número para seleccionar una opción, o escribir texto libre directamente (por ejemplo, "jquery", "i don't know")

6194. **Asignar respuestas**: El código verifica si la entrada es numérica (usa la etiqueta de la opción) o texto libre (usa el texto directamente)

6205. **Devolver a Claude**: La respuesta incluye tanto el array `questions` original como el mapeo `answers`

621

622<CodeGroup>

623 ```python Python theme={null}

624 import asyncio

625

626 from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query

627 from claude_agent_sdk.types import HookMatcher, PermissionResultAllow

628

629

630 def parse_response(response: str, options: list) -> str:

631 """Analizar la entrada del usuario como número(s) de opción o texto libre."""

632 try:

633 indices = [int(s.strip()) - 1 for s in response.split(",")]

634 labels = [options[i]["label"] for i in indices if 0 <= i < len(options)]

635 return ", ".join(labels) if labels else response

636 except ValueError:

637 return response

638

639

640 async def handle_ask_user_question(input_data: dict) -> PermissionResultAllow:

641 """Mostrar las preguntas de Claude y recopilar respuestas del usuario."""

642 answers = {}

643

644 for q in input_data.get("questions", []):

645 print(f"\n{q['header']}: {q['question']}")

646

647 options = q["options"]

648 for i, opt in enumerate(options):

649 print(f" {i + 1}. {opt['label']} - {opt['description']}")

650 if q.get("multiSelect"):

651 print(" (Enter numbers separated by commas, or type your own answer)")

652 else:

653 print(" (Enter a number, or type your own answer)")

654

655 response = input("Your choice: ").strip()

656 answers[q["question"]] = parse_response(response, options)

657

658 return PermissionResultAllow(

659 updated_input={

660 "questions": input_data.get("questions", []),

661 "answers": answers,

662 }

663 )

664

665

666 async def can_use_tool(

667 tool_name: str, input_data: dict, context

668 ) -> PermissionResultAllow:

669 # Enrutar AskUserQuestion a nuestro manejador de preguntas

670 if tool_name == "AskUserQuestion":

671 return await handle_ask_user_question(input_data)

672 # Auto-aprobar otras herramientas para este ejemplo

673 return PermissionResultAllow(updated_input=input_data)

674

675

676 async def prompt_stream():

677 yield {

678 "type": "user",

679 "message": {

680 "role": "user",

681 "content": "Help me decide on the tech stack for a new mobile app",

682 },

683 }

684

685

686 # Solución requerida: hook ficticio mantiene el flujo abierto para can_use_tool

687 async def dummy_hook(input_data, tool_use_id, context):

688 return {"continue_": True}

689

690

691 async def main():

692 async for message in query(

693 prompt=prompt_stream(),

694 options=ClaudeAgentOptions(

695 can_use_tool=can_use_tool,

696 hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[dummy_hook])]},

697 ),

698 ):

699 if isinstance(message, ResultMessage) and message.subtype == "success":

700 print(message.result)

701

702

703 asyncio.run(main())

704 ```

705

706 ```typescript TypeScript theme={null}

707 import { query } from "@anthropic-ai/claude-agent-sdk";

708 import * as readline from "readline/promises";

709

710 // Helper para solicitar entrada del usuario en la terminal

711 async function prompt(question: string): Promise<string> {

712 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

713 const answer = await rl.question(question);

714 rl.close();

715 return answer;

716 }

717

718 // Analizar la entrada del usuario como número(s) de opción o texto libre

719 function parseResponse(response: string, options: any[]): string {

720 const indices = response.split(",").map((s) => parseInt(s.trim()) - 1);

721 const labels = indices

722 .filter((i) => !isNaN(i) && i >= 0 && i < options.length)

723 .map((i) => options[i].label);

724 return labels.length > 0 ? labels.join(", ") : response;

725 }

726

727 // Mostrar las preguntas de Claude y recopilar respuestas del usuario

728 async function handleAskUserQuestion(input: any) {

729 const answers: Record<string, string> = {};

730

731 for (const q of input.questions) {

732 console.log(`\n${q.header}: ${q.question}`);

733

734 const options = q.options;

735 options.forEach((opt: any, i: number) => {

736 console.log(` ${i + 1}. ${opt.label} - ${opt.description}`);

737 });

738 if (q.multiSelect) {

739 console.log(" (Enter numbers separated by commas, or type your own answer)");

740 } else {

741 console.log(" (Enter a number, or type your own answer)");

742 }

743

744 const response = (await prompt("Your choice: ")).trim();

745 answers[q.question] = parseResponse(response, options);

746 }

747

748 // Devolver las respuestas a Claude (debe incluir preguntas originales)

749 return {

750 behavior: "allow",

751 updatedInput: { questions: input.questions, answers }

752 };

753 }

754

755 async function main() {

756 for await (const message of query({

757 prompt: "Help me decide on the tech stack for a new mobile app",

758 options: {

759 canUseTool: async (toolName, input) => {

760 // Enrutar AskUserQuestion a nuestro manejador de preguntas

761 if (toolName === "AskUserQuestion") {

762 return handleAskUserQuestion(input);

763 }

764 // Auto-aprobar otras herramientas para este ejemplo

765 return { behavior: "allow", updatedInput: input };

766 }

767 }

768 })) {

769 if ("result" in message) console.log(message.result);

770 }

771 }

772

773 main();

774 ```

775</CodeGroup>

776

777## Limitaciones

778

779* **Subagentes**: `AskUserQuestion` no está disponible actualmente en subagentes generados a través de la herramienta Agent

780* **Límites de preguntas**: cada llamada `AskUserQuestion` admite 1-4 preguntas con 2-4 opciones cada una

781

782## Otras formas de obtener entrada del usuario

783

784El callback `canUseTool` y la herramienta `AskUserQuestion` cubren la mayoría de escenarios de aprobación y aclaración, pero el SDK ofrece otras formas de obtener entrada de los usuarios:

785

786### Entrada de flujo

787

788Use [entrada de flujo](/es/agent-sdk/streaming-vs-single-mode) cuando necesite:

789

790* **Interrumpir el agente a mitad de tarea**: enviar una señal de cancelación o cambiar de dirección mientras Claude está trabajando

791* **Proporcionar contexto adicional**: agregar información que Claude necesita sin esperar a que la solicite

792* **Construir interfaces de chat**: permitir que los usuarios envíen mensajes de seguimiento durante operaciones de larga duración

793

794La entrada de flujo es ideal para interfaces conversacionales donde los usuarios interactúan con el agente durante toda la ejecución, no solo en puntos de aprobación.

795

796### Herramientas personalizadas

797

798Use [herramientas personalizadas](/es/agent-sdk/custom-tools) cuando necesite:

799

800* **Recopilar entrada estructurada**: construir formularios, asistentes o flujos de trabajo de varios pasos que vayan más allá del formato de opción múltiple de `AskUserQuestion`

801* **Integrar sistemas de aprobación externos**: conectarse a plataformas de tickets, flujo de trabajo o aprobación existentes

802* **Implementar interacciones específicas del dominio**: crear herramientas adaptadas a las necesidades de su aplicación, como interfaces de revisión de código o listas de verificación de implementación

803

804Las herramientas personalizadas le dan control total sobre la interacción, pero requieren más trabajo de implementación que usar el callback `canUseTool` integrado.

805

806## Recursos relacionados

807

808* [Configurar permisos](/es/agent-sdk/permissions): configurar modos y reglas de permisos

809* [Controlar la ejecución con hooks](/es/agent-sdk/hooks): ejecutar código personalizado en puntos clave del ciclo de vida del agente

810* [Referencia del SDK de TypeScript](/es/agent-sdk/typescript#canusetool): documentación completa de la API canUseTool

auto-mode-config.md +17 −12

Details

24* [Inspeccionar su configuración efectiva](#inspect-the-defaults-and-your-effective-config) con los subcomandos `claude auto-mode`24* [Inspeccionar su configuración efectiva](#inspect-the-defaults-and-your-effective-config) con los subcomandos `claude auto-mode`

25* [Revisar denegaciones](#review-denials) para saber qué agregar a continuación25* [Revisar denegaciones](#review-denials) para saber qué agregar a continuación

26 26

~~27## Where the classifier reads configuration~~27## Dónde el clasificador lee la configuración

28 28

29El clasificador lee el mismo contenido [CLAUDE.md](/es/memory) que carga Claude, por lo que una instrucción como "nunca force push" en el CLAUDE.md de su proyecto dirige tanto a Claude como al clasificador al mismo tiempo. Comience allí para convenciones de proyecto y reglas de comportamiento.29El clasificador lee el mismo contenido [CLAUDE.md](/es/memory) que carga Claude, por lo que una instrucción como "nunca force push" en el CLAUDE.md de su proyecto dirige tanto a Claude como al clasificador al mismo tiempo. Comience allí para convenciones de proyecto y reglas de comportamiento.

30 30

39 39

40El clasificador no lee `autoMode` de la configuración de proyecto compartida en `.claude/settings.json`, por lo que un repositorio registrado no puede inyectar sus propias reglas de permiso.40El clasificador no lee `autoMode` de la configuración de proyecto compartida en `.claude/settings.json`, por lo que un repositorio registrado no puede inyectar sus propias reglas de permiso.

41 41

42Las entradas de cada ámbito se combinan. Un desarrollador puede extender `environment`, `allow` y `soft_deny` con entradas personales pero no puede eliminar entradas que proporciona la configuración administrada. Debido a que las reglas de permiso actúan como excepciones a las reglas de bloqueo dentro del clasificador, una entrada `allow` agregada por un desarrollador puede anular una entrada `soft_deny` de la organización: la combinación es aditiva, no un límite de política dura.42Las entradas de cada ámbito se combinan. Un desarrollador puede extender `environment`, `allow`, `soft_deny` y `hard_deny` con entradas personales pero no puede eliminar entradas que proporciona la configuración administrada. Debido a que las reglas de permiso actúan como excepciones a las reglas de bloqueo suave dentro del clasificador, una entrada `allow` agregada por un desarrollador puede anular una entrada `soft_deny` de la organización: la combinación es aditiva, no un límite de política dura.

43 43

44<Note>44<Note>

45 El clasificador es una segunda puerta que se ejecuta después del [sistema de permisos](/es/permissions). Para acciones que nunca deben ejecutarse independientemente de la intención del usuario o la configuración del clasificador, utilice `permissions.deny` en la configuración administrada, que bloquea la acción antes de que se consulte el clasificador y no puede ser anulada.45 El clasificador es una segunda puerta que se ejecuta después del [sistema de permisos](/es/permissions). Para acciones que nunca deben ejecutarse independientemente de la intención del usuario o la configuración del clasificador, utilice `permissions.deny` en la configuración administrada, que bloquea la acción antes de que se consulte el clasificador y no puede ser anulada.

99 99

100## Anular las reglas de bloqueo y permiso100## Anular las reglas de bloqueo y permiso

101 101

102Dos campos adicionales le permiten reemplazar las listas de reglas integradas del clasificador: `autoMode.soft_deny` controla qué se bloquea, y `autoMode.allow` controla qué excepciones se aplican. Cada uno es una matriz de descripciones en prosa, leídas como reglas en lenguaje natural. No hay un campo `autoMode.deny`; para bloquear una acción de forma permanente independientemente de la intención, utilice [`permissions.deny`](/es/permissions), que se ejecuta antes del clasificador.102Tres campos adicionales le permiten reemplazar las listas de reglas integradas del clasificador: `autoMode.hard_deny` para límites de seguridad incondicionales, `autoMode.soft_deny` para acciones destructivas que la intención del usuario puede anular, y `autoMode.allow` para excepciones. Cada uno es una matriz de descripciones en prosa, leídas como reglas en lenguaje natural. Para bloqueos basados en patrones de herramientas que se ejecutan antes del clasificador, utilice [`permissions.deny`](/es/permissions).

103 103

104Dentro del clasificador, la precedencia funciona en tres niveles:104Dentro del clasificador, la precedencia funciona en cuatro niveles:

105 105

106* Las reglas `soft_deny` bloquean primero106* Las reglas `hard_deny` bloquean incondicionalmente. La intención del usuario y las excepciones `allow` no se aplican.

107* Las reglas `allow` luego anulan los bloqueos coincidentes como excepciones107* Las reglas `soft_deny` bloquean a continuación. La intención del usuario y las excepciones `allow` pueden anular estas.

108* La intención explícita del usuario anula ambas: si el mensaje del usuario describe directa y específicamente la acción exacta que Claude está a punto de tomar, el clasificador la permite incluso cuando una regla `soft_deny` coincide108* Las reglas `allow` luego anulan las reglas `soft_deny` coincidentes como excepciones.

109* La intención explícita del usuario anula los bloqueos suaves restantes: si el mensaje del usuario describe directa y específicamente la acción exacta que Claude está a punto de tomar, el clasificador la permite incluso cuando una regla `soft_deny` coincide.

109 110

110Las solicitudes generales no cuentan como intención explícita. Pedirle a Claude que "limpie el repositorio" no autoriza force-push, pero pedirle que "force-push esta rama" sí.111Las solicitudes generales no cuentan como intención explícita. Pedirle a Claude que "limpie el repositorio" no autoriza force-push, pero pedirle que "force-push esta rama" sí.

111 112

112Para flexibilizar, agregue a `allow` cuando el clasificador marca repetidamente un patrón rutinario que las excepciones predeterminadas no cubren. Para endurecer, agregue a `soft_deny` para riesgos específicos de su entorno que los valores predeterminados pierden. Para mantener las reglas integradas mientras agrega las suyas propias, incluya la cadena literal `"$defaults"` en la matriz. Las reglas predeterminadas se insertan en esa posición, por lo que sus reglas personalizadas pueden ir antes o después de ellas, y continúa heredando actualizaciones a medida que la lista integrada cambia en las versiones.113Para flexibilizar, agregue a `allow` cuando el clasificador marca repetidamente un patrón rutinario que las excepciones predeterminadas no cubren. Para endurecer, agregue a `soft_deny` para riesgos destructivos específicos de su entorno que los valores predeterminados pierden, o a `hard_deny` para límites de seguridad que nunca deben cruzarse. Para mantener las reglas integradas mientras agrega las suyas propias, incluya la cadena literal `"$defaults"` en la matriz. Las reglas predeterminadas se insertan en esa posición, por lo que sus reglas personalizadas pueden ir antes o después de ellas, y continúa heredando actualizaciones a medida que la lista integrada cambia en las versiones.

113 114

114```json theme={null}115```json theme={null}

115{116{

127 "$defaults",128 "$defaults",

128 "Never run database migrations outside the migrations CLI, even against dev databases",129 "Never run database migrations outside the migrations CLI, even against dev databases",

129 "Never modify files under infra/terraform/prod/: production infrastructure changes go through the review workflow"130 "Never modify files under infra/terraform/prod/: production infrastructure changes go through the review workflow"

131 ],

132 "hard_deny": [

133 "$defaults",

134 "Never send repository contents to third-party code-review APIs"

130 ]135 ]

131 }136 }

132}137}

133```138```

134 139

135<Danger>140<Danger>

136 Establecer cualquiera de `environment`, `allow` o `soft_deny` sin `"$defaults"` reemplaza la lista predeterminada completa para esa sección. Si establece `soft_deny` con una sola entrada y omite `"$defaults"`, se descartan todas las reglas de bloqueo integradas: force push, exfiltración de datos, `curl | bash`, despliegues de producción y todas las demás reglas de bloqueo predeterminadas se permiten. Solo omita `"$defaults"` cuando tenga la intención de asumir la propiedad completa de la lista. En ese caso, ejecute `claude auto-mode defaults` para imprimir las reglas integradas, cópielas en su archivo de configuración, luego revise cada regla contra su propia canalización y tolerancia al riesgo.141 Establecer cualquiera de `environment`, `allow`, `soft_deny` o `hard_deny` sin `"$defaults"` reemplaza la lista predeterminada completa para esa sección. Una matriz `soft_deny` sin `"$defaults"` descarta todas las reglas de bloqueo integradas, incluido force push, `curl | bash` y despliegues de producción. Una matriz `hard_deny` sin `"$defaults"` descarta las reglas integradas de exfiltración de datos y omisión de verificación de seguridad.

137</Danger>142</Danger>

138 143

139Cada sección se evalúa de forma independiente, por lo que establecer `environment` solo deja intactas las listas predeterminadas `allow` y `soft_deny`.144Cada sección se evalúa de forma independiente, por lo que establecer `environment` solo deja intactas las listas predeterminadas `allow`, `soft_deny` y `hard_deny`. Solo omita `"$defaults"` cuando tenga la intención de asumir la propiedad completa de la lista. Para hacerlo de forma segura, ejecute `claude auto-mode defaults` para imprimir las reglas integradas, cópielas en su archivo de configuración, luego revise cada regla contra su propia canalización y tolerancia al riesgo.

140 145

141## Inspeccione los valores predeterminados y su configuración efectiva146## Inspeccione los valores predeterminados y su configuración efectiva

142 147

143Tres subcomandos de CLI lo ayudan a inspeccionar y validar su configuración.148Tres subcomandos de CLI lo ayudan a inspeccionar y validar su configuración.

144 149

145Imprima las reglas `environment`, `allow` y `soft_deny` integradas como JSON:150Imprima las reglas `environment`, `allow`, `soft_deny` y `hard_deny` integradas como JSON:

146 151

147```bash theme={null}152```bash theme={null}

148claude auto-mode defaults153claude auto-mode defaults

154claude auto-mode config159claude auto-mode config

155```160```

156 161

157Obtenga retroalimentación de IA sobre sus reglas `allow` y `soft_deny` personalizadas:162Obtenga retroalimentación de IA sobre sus reglas `allow`, `soft_deny` y `hard_deny` personalizadas:

158 163

159```bash theme={null}164```bash theme={null}

160claude auto-mode critique165claude auto-mode critique

commands.md +3 −2

Details

46| `/btw <question>` | Hacer una [pregunta rápida](/es/interactive-mode#side-questions-with-%2Fbtw) sin agregar a la conversación |46| `/btw <question>` | Hacer una [pregunta rápida](/es/interactive-mode#side-questions-with-%2Fbtw) sin agregar a la conversación |

48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/es/skills#bundled-skills).** Cargar material de referencia de la API de Claude para el idioma de su proyecto (Python, TypeScript, Java, Go, Ruby, C#, PHP o cURL) y referencia de Managed Agents. Cubre uso de herramientas, streaming, lotes, salidas estructuradas y trampas comunes. También se activa automáticamente cuando su código importa `anthropic` o `@anthropic-ai/sdk`. Ejecute `/claude-api migrate` para actualizar el código existente de la API de Claude a un modelo más nuevo: Claude pregunta qué archivos escanear y qué modelo dirigirse, luego actualiza los ID de modelo, configuración de pensamiento y otros parámetros que cambiaron entre versiones. Ejecute `/claude-api managed-agents-onboard` para un tutorial interactivo que crea un nuevo Managed Agent desde cero |48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/es/skills#bundled-skills).** Cargar material de referencia de la API de Claude para el idioma de su proyecto (Python, TypeScript, Java, Go, Ruby, C#, PHP o cURL) y referencia de Managed Agents. Cubre uso de herramientas, streaming, lotes, salidas estructuradas y trampas comunes. También se activa automáticamente cuando su código importa `anthropic` o `@anthropic-ai/sdk`. Ejecute `/claude-api migrate` para actualizar el código existente de la API de Claude a un modelo más nuevo: Claude pregunta qué archivos escanear y qué modelo dirigirse, luego actualiza los ID de modelo, configuración de pensamiento y otros parámetros que cambiaron entre versiones. Ejecute `/claude-api managed-agents-onboard` para un tutorial interactivo que crea un nuevo Managed Agent desde cero |

49| `/clear` | Iniciar una nueva conversación con contexto vacío. La conversación anterior permanece disponible en `/resume`. Para liberar contexto mientras continúa la misma conversación, use `/compact` en su lugar. Alias: `/reset`, `/new` |49| `/clear [name]` | Iniciar una nueva conversación con contexto vacío. La conversación anterior permanece disponible en `/resume`. Pase un nombre para etiquetar la conversación anterior en el selector `/resume`. Para liberar contexto mientras continúa la misma conversación, use `/compact` en su lugar. Alias: `/reset`, `/new` |

50| `/color [color\|default]` | Establecer el color de la barra de solicitud para la sesión actual. Colores disponibles: `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Use `default` para restablecer, o ejecute sin argumento para elegir un color aleatorio. Cuando [Remote Control](/es/remote-control) está conectado, el color se sincroniza con claude.ai/code |50| `/color [color\|default]` | Establecer el color de la barra de solicitud para la sesión actual. Colores disponibles: `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Use `default` para restablecer, o ejecute sin argumento para elegir un color aleatorio. Cuando [Remote Control](/es/remote-control) está conectado, el color se sincroniza con claude.ai/code |

51| `/compact [instructions]` | Liberar contexto resumiendo la conversación hasta ahora. Opcionalmente pase instrucciones de enfoque para el resumen. Consulte [cómo la compactación maneja reglas, skills y archivos de memoria](/es/context-window#what-survives-compaction) |51| `/compact [instructions]` | Liberar contexto resumiendo la conversación hasta ahora. Opcionalmente pase instrucciones de enfoque para el resumen. Consulte [cómo la compactación maneja reglas, skills y archivos de memoria](/es/context-window#what-survives-compaction) |

52| `/config` | Abrir la interfaz de [Settings](/es/settings) para ajustar tema, modelo, [estilo de salida](/es/output-styles) y otras preferencias. Alias: `/settings` |52| `/config` | Abrir la interfaz de [Settings](/es/settings) para ajustar tema, modelo, [estilo de salida](/es/output-styles) y otras preferencias. Alias: `/settings` |

53| `/context` | Visualizar el uso actual del contexto como una cuadrícula de colores. Muestra sugerencias de optimización para herramientas con mucho contexto, inflación de memoria y advertencias de capacidad |53| `/context [all]` | Visualizar el uso actual del contexto como una cuadrícula de colores. Muestra sugerencias de optimización para herramientas con mucho contexto, inflación de memoria y advertencias de capacidad. En [modo de pantalla completa](/es/fullscreen) el desglose por elemento se colapsa para mantener la cuadrícula visible. Pase `all` para expandirlo |

54| `/copy [N]` | Copiar la última respuesta del asistente al portapapeles. Pase un número `N` para copiar la respuesta N-ésima más reciente: `/copy 2` copia la segunda más reciente. Cuando hay bloques de código presentes, muestra un selector interactivo para seleccionar bloques individuales o la respuesta completa. Presione `w` en el selector para escribir la selección en un archivo en lugar del portapapeles, lo cual es útil a través de SSH |54| `/copy [N]` | Copiar la última respuesta del asistente al portapapeles. Pase un número `N` para copiar la respuesta N-ésima más reciente: `/copy 2` copia la segunda más reciente. Cuando hay bloques de código presentes, muestra un selector interactivo para seleccionar bloques individuales o la respuesta completa. Presione `w` en el selector para escribir la selección en un archivo en lugar del portapapeles, lo cual es útil a través de SSH |

56| `/debug [description]` | **[Skill](/es/skills#bundled-skills).** Habilitar registro de depuración para la sesión actual y solucionar problemas leyendo el registro de depuración de la sesión. El registro de depuración está desactivado de forma predeterminada a menos que haya iniciado con `claude --debug`, por lo que ejecutar `/debug` a mitad de sesión comienza a capturar registros desde ese punto en adelante. Opcionalmente describa el problema para enfocar el análisis |56| `/debug [description]` | **[Skill](/es/skills#bundled-skills).** Habilitar registro de depuración para la sesión actual y solucionar problemas leyendo el registro de depuración de la sesión. El registro de depuración está desactivado de forma predeterminada a menos que haya iniciado con `claude --debug`, por lo que ejecutar `/debug` a mitad de sesión comienza a capturar registros desde ese punto en adelante. Opcionalmente describa el problema para enfocar el análisis |

88| `/powerup` | Descubrir características de Claude Code a través de lecciones interactivas rápidas con demostraciones animadas |88| `/powerup` | Descubrir características de Claude Code a través de lecciones interactivas rápidas con demostraciones animadas |

89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Eliminado en v2.1.91. Pida a Claude directamente que vea comentarios de solicitud de extracción en su lugar. En versiones anteriores, obtiene y muestra comentarios de una solicitud de extracción de GitHub; detecta automáticamente la PR para la rama actual, o pase una URL o número de PR. Requiere la CLI `gh` |89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Eliminado en v2.1.91. Pida a Claude directamente que vea comentarios de solicitud de extracción en su lugar. En versiones anteriores, obtiene y muestra comentarios de una solicitud de extracción de GitHub; detecta automáticamente la PR para la rama actual, o pase una URL o número de PR. Requiere la CLI `gh` |

90| `/privacy-settings` | Ver y actualizar su configuración de privacidad. Solo disponible para suscriptores de planes Pro y Max |90| `/privacy-settings` | Ver y actualizar su configuración de privacidad. Solo disponible para suscriptores de planes Pro y Max |

91| `/radio` | Abrir Claude FM lo-fi radio en su navegador. Imprime la URL de transmisión cuando no hay navegador disponible. No disponible en Bedrock, Vertex o Foundry |

91| `/recap` | Generar un resumen de una línea de la sesión actual bajo demanda. Consulte [Session recap](/es/interactive-mode#session-recap) para el resumen automático que aparece después de que ha estado ausente |92| `/recap` | Generar un resumen de una línea de la sesión actual bajo demanda. Consulte [Session recap](/es/interactive-mode#session-recap) para el resumen automático que aparece después de que ha estado ausente |

92| `/release-notes` | Ver el registro de cambios en un selector de versión interactivo. Seleccione una versión específica para ver sus notas de lanzamiento, o elija mostrar todas las versiones |93| `/release-notes` | Ver el registro de cambios en un selector de versión interactivo. Seleccione una versión específica para ver sus notas de lanzamiento, o elija mostrar todas las versiones |

93| `/reload-plugins` | Recargar todos los [plugins](/es/plugins) activos para aplicar cambios pendientes sin reiniciar. Informa qué se cargó para cada componente recargado e indica cualquier error de carga |94| `/reload-plugins` | Recargar todos los [plugins](/es/plugins) activos para aplicar cambios pendientes sin reiniciar. Informa qué se cargó para cada componente recargado e indica cualquier error de carga |

env-vars.md +2 −0

Details

117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Número máximo de herramientas de solo lectura y subagentes que pueden ejecutarse en paralelo (predeterminado: 10). Los valores más altos aumentan el paralelismo pero consumen más recursos |117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Número máximo de herramientas de solo lectura y subagentes que pueden ejecutarse en paralelo (predeterminado: 10). Los valores más altos aumentan el paralelismo pero consumen más recursos |

118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Establezca en `1` para generar servidores MCP stdio con solo un entorno de línea base segura más el `env` configurado del servidor, en lugar de heredar su entorno de shell |118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Establezca en `1` para generar servidores MCP stdio con solo un entorno de línea base segura más el `env` configurado del servidor, en lugar de heredar su entorno de shell |

119| `CLAUDE_CODE_NATIVE_CURSOR` | Establezca en `1` para mostrar el cursor propio del terminal en el símbolo de inserción en lugar de un bloque dibujado. El cursor respeta la configuración de parpadeo, forma y enfoque del terminal |

119| `CLAUDE_CODE_NEW_INIT` | Establezca en `1` para hacer que `/init` ejecute un flujo de configuración interactivo. El flujo pregunta qué archivos generar, incluidos CLAUDE.md, skills y hooks, antes de explorar la base de código y escribirlos. Sin esta variable, `/init` genera un CLAUDE.md automáticamente sin solicitar. |120| `CLAUDE_CODE_NEW_INIT` | Establezca en `1` para hacer que `/init` ejecute un flujo de configuración interactivo. El flujo pregunta qué archivos generar, incluidos CLAUDE.md, skills y hooks, antes de explorar la base de código y escribirlos. Sin esta variable, `/init` genera un CLAUDE.md automáticamente sin solicitar. |

120| `CLAUDE_CODE_NO_FLICKER` | Establezca en `1` para habilitar [renderizado a pantalla completa](/es/fullscreen), una vista previa de investigación que reduce el parpadeo y mantiene la memoria plana en conversaciones largas. Equivalente a la configuración [`tui`](/es/settings#available-settings); también puede cambiar con `/tui fullscreen` |121| `CLAUDE_CODE_NO_FLICKER` | Establezca en `1` para habilitar [renderizado a pantalla completa](/es/fullscreen), una vista previa de investigación que reduce el parpadeo y mantiene la memoria plana en conversaciones largas. Equivalente a la configuración [`tui`](/es/settings#available-settings); también puede cambiar con `/tui fullscreen` |

121| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | Token de actualización de OAuth para autenticación de Claude.ai. Cuando se establece, `claude auth login` intercambia este token directamente en lugar de abrir un navegador. Requiere `CLAUDE_CODE_OAUTH_SCOPES`. Útil para aprovisionar autenticación en entornos automatizados |122| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | Token de actualización de OAuth para autenticación de Claude.ai. Cuando se establece, `claude auth login` intercambia este token directamente en lugar de abrir un navegador. Requiere `CLAUDE_CODE_OAUTH_SCOPES`. Útil para aprovisionar autenticación en entornos automatizados |

191| `DISABLE_TELEMETRY` | Establezca en `1` para optar por no participar en la telemetría. Los eventos de telemetría no incluyen datos de usuario como código, rutas de archivo o comandos bash |192| `DISABLE_TELEMETRY` | Establezca en `1` para optar por no participar en la telemetría. Los eventos de telemetría no incluyen datos de usuario como código, rutas de archivo o comandos bash |

192| `DISABLE_UPDATES` | Establezca en `1` para bloquear todas las actualizaciones, incluido el comando manual `claude update` y `claude install`. Más estricto que `DISABLE_AUTOUPDATER`. Utilice cuando distribuya Claude Code a través de sus propios canales y los usuarios no deben auto-actualizarse |193| `DISABLE_UPDATES` | Establezca en `1` para bloquear todas las actualizaciones, incluido el comando manual `claude update` y `claude install`. Más estricto que `DISABLE_AUTOUPDATER`. Utilice cuando distribuya Claude Code a través de sus propios canales y los usuarios no deben auto-actualizarse |

195| `DO_NOT_TRACK` | Establezca en `1` para optar por no participar en la telemetría. Equivalente a establecer `DISABLE_TELEMETRY`. Honrado como la [convención estándar entre herramientas](https://consoledonottrack.com/) |

194| `ENABLE_CLAUDEAI_MCP_SERVERS` | Establezca en `false` para deshabilitar [servidores MCP de claude.ai](/es/mcp#use-mcp-servers-from-claude-ai) en Claude Code. Habilitado de forma predeterminada para usuarios conectados |196| `ENABLE_CLAUDEAI_MCP_SERVERS` | Establezca en `false` para deshabilitar [servidores MCP de claude.ai](/es/mcp#use-mcp-servers-from-claude-ai) en Claude Code. Habilitado de forma predeterminada para usuarios conectados |

195| `ENABLE_PROMPT_CACHING_1H` | Establezca en `1` para solicitar un TTL de caché de indicador de 1 hora en lugar de los 5 minutos predeterminados. Destinado a usuarios de clave de API, [Bedrock](/es/amazon-bedrock), [Vertex](/es/google-vertex-ai) y [Foundry](/es/microsoft-foundry). Los usuarios de suscripción reciben TTL de 1 hora automáticamente. Las escrituras de caché de 1 hora se facturan a una tasa más alta |197| `ENABLE_PROMPT_CACHING_1H` | Establezca en `1` para solicitar un TTL de caché de indicador de 1 hora en lugar de los 5 minutos predeterminados. Destinado a usuarios de clave de API, [Bedrock](/es/amazon-bedrock), [Vertex](/es/google-vertex-ai) y [Foundry](/es/microsoft-foundry). Los usuarios de suscripción reciben TTL de 1 hora automáticamente. Las escrituras de caché de 1 hora se facturan a una tasa más alta |

errors.md +16 −0

Details

34| `Routines are disabled by your organization's policy` | [Autenticación](#routines-are-disabled-by-your-organizations-policy) |

252* Ejecute `/status` después para confirmar que la credencial activa es su suscripción253* Ejecute `/status` después para confirmar que la credencial activa es su suscripción

253* Si no hay variable de entorno configurada y el error persiste, la organización deshabilitada es la vinculada a su `/login`. Póngase en contacto con el soporte o inicie sesión con una cuenta diferente.254* Si no hay variable de entorno configurada y el error persiste, la organización deshabilitada es la vinculada a su `/login`. Póngase en contacto con el soporte o inicie sesión con una cuenta diferente.

254 255

256### Routines are disabled by your organization's policy

257

258Su administrador de Team o Enterprise ha desactivado las rutinas a nivel de organización. El error aparece cuando intenta crear o ejecutar una rutina, incluyendo desde `/schedule` y la interfaz de usuario [Routines](/es/routines) en claude.ai/code.

259

260```text theme={null}

261Routines are disabled by your organization's policy.

262```

263

264Esta es una configuración del lado del servidor, por lo que no se puede anular desde la configuración local, variables de entorno o banderas de CLI.

265

266**Qué hacer:**

267

268* Pida a su administrador que habilite el botón **Routines** en [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code)

269* Para trabajo programado único que no requiere rutinas a nivel de organización, consulte [scheduled tasks](/es/scheduled-tasks)

270

255### OAuth token revoked or expired271### OAuth token revoked or expired

256 272

257Su inicio de sesión guardado ya no es válido. Un token revocado significa que cerró sesión en todas partes o un administrador eliminó el acceso; un token expirado significa que la actualización automática falló a mitad de sesión.273Su inicio de sesión guardado ya no es válido. Un token revocado significa que cerró sesión en todas partes o un administrador eliminó el acceso; un token expirado significa que la actualización automática falló a mitad de sesión.

interactive-mode.md +1 −1

Details

289 289

290Después de que Claude responde, las sugerencias continúan apareciendo según su historial de conversación, como un paso de seguimiento de una solicitud de varias partes o una continuación natural de su flujo de trabajo.290Después de que Claude responde, las sugerencias continúan apareciendo según su historial de conversación, como un paso de seguimiento de una solicitud de varias partes o una continuación natural de su flujo de trabajo.

291 291

292* Presione **Tab** o **Flecha derecha** para aceptar la sugerencia, o presione **Enter** para aceptar y enviar292* Presione **Tab** o **Flecha derecha** para colocar la sugerencia en la entrada de indicación, luego **Intro** para enviar

293* Comience a escribir para descartarla293* Comience a escribir para descartarla

294 294

295La sugerencia se ejecuta como una solicitud de fondo que reutiliza el caché de indicación de la conversación principal, por lo que el costo adicional es mínimo. Claude Code omite la generación de sugerencias cuando el caché está frío para evitar costos innecesarios.295La sugerencia se ejecuta como una solicitud de fondo que reutiliza el caché de indicación de la conversación principal, por lo que el costo adicional es mínimo. Claude Code omite la generación de sugerencias cuando el caché está frío para evitar costos innecesarios.

mcp.md +2 −0

Details

265 --header "Authorization: Bearer your-token"265 --header "Authorization: Bearer your-token"

266```266```

267 267

268Cuando configure servidores MCP a través de JSON en `.mcp.json`, `~/.claude.json`, o `claude mcp add-json`, el campo `type` acepta `streamable-http` como un alias para `http`. La especificación de MCP utiliza el nombre `streamable-http` para este transporte, por lo que las configuraciones copiadas de la documentación del servidor funcionan sin modificación.

269

268### Opción 2: Agregar un servidor SSE remoto270### Opción 2: Agregar un servidor SSE remoto

269 271

270<Warning>272<Warning>

permissions.md +7 −0

Details

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

211* `Read(src/**)`: lee desde `<current-directory>/src/`211* `Read(src/**)`: lee desde `<current-directory>/src/`

212 212

213Una regla solo coincide con archivos bajo su anclaje, por lo que el anclaje determina cuán lejos llega una regla de negación. Los nombres de archivo desnudos siguen la semántica de gitignore y coinciden en cualquier profundidad, por lo que `Read(.env)` y `Read(**/.env)` son equivalentes:

214

215| Regla de negación | Bloquea | No bloquea |

216| ------------------------------ | ----------------------------------------------------------- | -------------------------------------------------------------- |

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

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

219

213<Note>220<Note>

214 En patrones gitignore, `*` coincide con archivos en un solo directorio mientras que `**` coincide recursivamente en directorios. Para permitir todo acceso a archivos, use solo el nombre de la herramienta sin paréntesis: `Read`, `Edit` o `Write`.221 En patrones gitignore, `*` coincide con archivos en un solo directorio mientras que `**` coincide recursivamente en directorios. Para permitir todo acceso a archivos, use solo el nombre de la herramienta sin paréntesis: `Read`, `Edit` o `Write`.

215</Note>222</Note>

plugins-reference.md +8 −3

Details

423 423

425| :---------------------- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |425| :---------------------- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |

510 510

511### Reglas de comportamiento de rutas511### Reglas de comportamiento de rutas

512 512

513Para `skills`, `commands`, `agents`, `outputStyles`, `experimental.themes` y `experimental.monitors`, una ruta personalizada reemplaza la predeterminada. Si el manifiesto especifica `skills`, el directorio predeterminado `skills/` no se escanea; si especifica `experimental.monitors`, el `monitors/monitors.json` predeterminado no se carga. [Hooks](#hooks), [MCP servers](#mcp-servers) y [LSP servers](#lsp-servers) tienen semántica diferente para manejar múltiples fuentes.513Si una ruta personalizada reemplaza o extiende el directorio predeterminado del plugin depende del campo:

514

515* **Reemplaza el predeterminado**: `commands`, `agents`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Por ejemplo, cuando el manifiesto especifica `commands`, el directorio predeterminado `commands/` no se escanea. Para mantener el predeterminado y añadir más, enuméralo explícitamente: `"commands": ["./commands/", "./extras/"]`

516* **Se añade al predeterminado**: `skills`. El directorio predeterminado `skills/` siempre se escanea, y los directorios enumerados en `skills` se cargan junto a él

517* **Reglas de fusión propias**: [hooks](#hooks), [MCP servers](#mcp-servers) y [LSP servers](#lsp-servers). Consulta cada sección para ver cómo se combinan múltiples fuentes

518

519Para todos los campos de ruta:

514 520

515* Todas las rutas deben ser relativas a la raíz del plugin y comenzar con `./`521* Todas las rutas deben ser relativas a la raíz del plugin y comenzar con `./`

516* Los componentes de rutas personalizadas utilizan las mismas reglas de nomenclatura y espacios de nombres522* Los componentes de rutas personalizadas utilizan las mismas reglas de nomenclatura y espacios de nombres

517* Se pueden especificar múltiples rutas como arrays523* Se pueden especificar múltiples rutas como arrays

518* Para mantener el directorio predeterminado y añadir más rutas para skills, comandos, agents o estilos de salida, incluye el predeterminado en tu array: `"skills": ["./skills/", "./extras/"]`

519* Cuando una ruta de skill apunta a un directorio que contiene un `SKILL.md` directamente, por ejemplo `"skills": ["./"]` apuntando a la raíz del plugin, el campo frontmatter `name` en `SKILL.md` determina el nombre de invocación de la skill. Esto proporciona un nombre estable independientemente del directorio de instalación. Si `name` no se establece en el frontmatter, el nombre base del directorio se usa como alternativa.524* Cuando una ruta de skill apunta a un directorio que contiene un `SKILL.md` directamente, por ejemplo `"skills": ["./"]` apuntando a la raíz del plugin, el campo frontmatter `name` en `SKILL.md` determina el nombre de invocación de la skill. Esto proporciona un nombre estable independientemente del directorio de instalación. Si `name` no se establece en el frontmatter, el nombre base del directorio se usa como alternativa.

520 525

521**Ejemplos de rutas**:526**Ejemplos de rutas**:

routines.md +31 −23

Details

22 22

23Las rutinas están disponibles en planes Pro, Max, Team y Enterprise con [Claude Code en la web](/es/claude-code-on-the-web) habilitado. Créelas y adminístrelas en [claude.ai/code/routines](https://claude.ai/code/routines), o desde la CLI con `/schedule`.23Las rutinas están disponibles en planes Pro, Max, Team y Enterprise con [Claude Code en la web](/es/claude-code-on-the-web) habilitado. Créelas y adminístrelas en [claude.ai/code/routines](https://claude.ai/code/routines), o desde la CLI con `/schedule`.

24 24

25Los administradores de Team y Enterprise pueden desactivar las rutinas para todos los miembros con el botón de alternancia Routines en [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code). Cuando se desactivan, las rutinas existentes dejan de ejecutarse y los miembros no pueden crear nuevas.

25Esta página cubre la creación de una rutina, la configuración de cada tipo de disparador, la administración de ejecuciones y cómo se aplican los límites de uso.27Esta página cubre la creación de una rutina, la configuración de cada tipo de disparador, la administración de ejecuciones y cómo se aplican los límites de uso.

26 28

27## Casos de uso de ejemplo29## Casos de uso de ejemplo

122 124

123## Configurar disparadores125## Configurar disparadores

124 126

125Una rutina comienza cuando uno de sus disparadores coincide. Puede adjuntar cualquier combinación de disparadores de horario, API y GitHub a la misma rutina, y agregarlos o quitarlos en cualquier momento desde la sección **Seleccionar un disparador** del formulario de edición de la rutina.127Una rutina comienza cuando uno de sus disparadores coincide. Puede adjuntar cualquier combinación de disparadores de horario, API y GitHub a la misma rutina, y agregarlos o quitarlos en cualquier momento desde la sección **Select a trigger** del formulario de edición de la rutina.

126 128

127### Agregar un disparador de horario129### Agregar un disparador de horario

128 130

129Un disparador de horario ejecuta la rutina en una cadencia recurrente, u una sola vez en un momento futuro específico. Elija una frecuencia preestablecida en la sección **Seleccionar un disparador**: cada hora, diaria, días de semana o semanal. Los tiempos se ingresan en su zona local y se convierten automáticamente, por lo que la rutina se ejecuta a esa hora de reloj de pared independientemente de dónde se encuentre la infraestructura en la nube.131Un disparador de horario ejecuta la rutina en una cadencia recurrente, o una sola vez en un momento futuro específico. Elija una frecuencia preestablecida en la sección **Select a trigger**: cada hora, diaria, días de semana o semanal. Los tiempos se ingresan en su zona local y se convierten automáticamente, por lo que la rutina se ejecuta a esa hora de reloj de pared independientemente de dónde se encuentre la infraestructura en la nube.

130 132

131Las ejecuciones pueden comenzar unos minutos después de la hora programada debido al escalonamiento. El desplazamiento es consistente para cada rutina.133Las ejecuciones pueden comenzar unos minutos después de la hora programada debido al escalonamiento. El desplazamiento es consistente para cada rutina.

132 134

134 136

135#### Programar una ejecución única137#### Programar una ejecución única

136 138

137Una programación única dispara la rutina una sola vez en una marca de tiempo específica. Úsela para recordarse más adelante en la semana, para abrir un PR de limpieza después de que finalice un despliegue, o para iniciar una tarea de seguimiento cuando llega un cambio ascendente. Después de que se dispara la rutina, se desactiva automáticamente y la interfaz de usuario web la marca como **Ejecutada**. Para ejecutarla nuevamente, edite la rutina y establezca una nueva hora única.139Una programación única dispara la rutina una sola vez en una marca de tiempo específica. Úsela para recordarse más adelante en la semana, para abrir un PR de limpieza después de que finalice un despliegue, o para iniciar una tarea de seguimiento cuando llega un cambio ascendente. Después de que se dispara la rutina, se desactiva automáticamente y la interfaz de usuario web la marca como **Ran**. Para ejecutarla nuevamente, edite la rutina y establezca una nueva hora única.

138 140

139Cree una ejecución única desde la CLI describiendo la hora en lenguaje natural. Claude resuelve la frase contra la hora actual y confirma la marca de tiempo absoluta antes de guardar.141Cree una ejecución única desde la CLI describiendo la hora en lenguaje natural. Claude resuelve la frase contra la hora actual y confirma la marca de tiempo absoluta antes de guardar.

140 142

158 160

159<Steps>161<Steps>

160 <Step title="Abrir la rutina para editar">162 <Step title="Abrir la rutina para editar">

161 Vaya a [claude.ai/code/routines](https://claude.ai/code/routines), haga clic en la rutina que desea activar a través de API, luego haga clic en el icono de lápiz para abrir **Editar rutina**.163 Vaya a [claude.ai/code/routines](https://claude.ai/code/routines), haga clic en la rutina que desea activar a través de API, luego haga clic en el icono de lápiz para abrir **Edit routine**.

162 </Step>164 </Step>

163 165

164 <Step title="Agregar un disparador de API">166 <Step title="Agregar un disparador de API">

165 Desplácese hasta la sección **Seleccionar un disparador** debajo del cuadro **Instrucciones**, haga clic en **Agregar otro disparador** y elija **API**.167 Desplácese hasta la sección **Select a trigger** debajo del cuadro **Instructions**, haga clic en **Add another trigger** y elija **API**.

166 </Step>168 </Step>

167 169

168 <Step title="Copiar la URL y generar un token">170 <Step title="Copiar la URL y generar un token">

169 El modal muestra la URL para esta rutina junto con un comando curl de ejemplo. Copie la URL, luego haga clic en **Generar token** y copie el token inmediatamente. El token se muestra una vez y no se puede recuperar más tarde, así que guárdelo en un lugar seguro como el almacén de secretos de su herramienta de alertas.171 El modal muestra la URL para esta rutina junto con un comando curl de ejemplo. Copie la URL, luego haga clic en **Generate token** y copie el token inmediatamente. El token se muestra una vez y no se puede recuperar más tarde, así que guárdelo en un lugar seguro como el almacén de secretos de su herramienta de alertas.

170 </Step>172 </Step>

171 173

172 <Step title="Llamar al punto final">174 <Step title="Llamar al punto final">

173 Envíe el token en el encabezado `Authorization: Bearer` cuando POST a la URL. La sección [Activar una rutina](#trigger-a-routine) a continuación muestra un ejemplo completo.175 Envíe el token en el encabezado `Authorization: Bearer` cuando POST a la URL. La sección [Trigger a routine](#trigger-a-routine) a continuación muestra un ejemplo completo.

174 </Step>176 </Step>

175</Steps>177</Steps>

176 178

177Cada rutina tiene su propio token, limitado a activar solo esa rutina. Para rotarlo o revocarlo, vuelva al mismo modal y haga clic en **Regenerar** o **Revocar**.179Cada rutina tiene su propio token, limitado a activar solo esa rutina. Para rotarlo o revocarlo, vuelva al mismo modal y haga clic en **Regenerate** o **Revoke**.

178 180

179#### Activar una rutina181#### Activar una rutina

180 182

209 211

210#### Referencia de API212#### Referencia de API

211 213

212Para la referencia completa de la API, incluidas todas las respuestas de error, reglas de validación y límites de campo, consulte [Activar una rutina a través de API](https://platform.claude.com/docs/es/api/claude-code/routines-fire) en la documentación de la plataforma Claude.214Para la referencia completa de la API, incluidas todas las respuestas de error, reglas de validación y límites de campo, consulte [Trigger a routine via API](https://platform.claude.com/docs/es/api/claude-code/routines-fire) en la documentación de la plataforma Claude.

213 215

214El punto final `/fire` está disponible solo para usuarios de claude.ai y no es parte de la superficie de la API de Claude Platform.216El punto final `/fire` está disponible solo para usuarios de claude.ai y no es parte de la superficie de la API de Claude Platform.

215 217

225 227

226<Steps>228<Steps>

227 <Step title="Abrir la rutina para editar">229 <Step title="Abrir la rutina para editar">

228 Vaya a [claude.ai/code/routines](https://claude.ai/code/routines), haga clic en la rutina, luego haga clic en el icono de lápiz para abrir **Editar rutina**.230 Vaya a [claude.ai/code/routines](https://claude.ai/code/routines), haga clic en la rutina, luego haga clic en el icono de lápiz para abrir **Edit routine**.

229 </Step>231 </Step>

230 232

231 <Step title="Agregar un disparador de evento de GitHub">233 <Step title="Agregar un disparador de evento de GitHub">

232 Desplácese hasta la sección **Seleccionar un disparador**, haga clic en **Agregar otro disparador** y elija **Evento de GitHub**.234 Desplácese hasta la sección **Select a trigger**, haga clic en **Add another trigger** y elija **GitHub event**.

233 </Step>235 </Step>

234 236

235 <Step title="Instalar la aplicación Claude GitHub">237 <Step title="Instalar la aplicación Claude GitHub">

299 301

300Desde la página de detalles de la rutina puede:302Desde la página de detalles de la rutina puede:

301 303

302* Haga clic en **Ejecutar ahora** para iniciar una ejecución inmediatamente sin esperar la próxima hora programada.304* Haga clic en **Run now** para iniciar una ejecución inmediatamente sin esperar la próxima hora programada.

303* Use el botón de alternancia en la sección **Se repite** para pausar o reanudar el horario. Las rutinas pausadas mantienen su configuración pero no se ejecutan hasta que las vuelva a habilitar.305* Use el botón de alternancia en la sección **Repeats** para pausar o reanudar el horario. Las rutinas pausadas mantienen su configuración pero no se ejecutan hasta que las vuelva a habilitar.

304* Haga clic en el icono de lápiz para abrir **Editar rutina** y cambiar el nombre, prompt, repositorios, entorno, conectores o cualquiera de los disparadores de la rutina. La sección **Seleccionar un disparador** es donde agrega o elimina horarios, tokens de API y disparadores de eventos de GitHub.306* Haga clic en el icono de lápiz para abrir **Edit routine** y cambiar el nombre, prompt, repositorios, entorno, conectores o cualquiera de los disparadores de la rutina. La sección **Select a trigger** es donde agrega o elimina horarios, tokens de API y disparadores de eventos de GitHub.

305* Haga clic en el icono de eliminar para eliminar la rutina. Las sesiones anteriores creadas por la rutina permanecen en su lista de sesiones.307* Haga clic en el icono de eliminar para eliminar la rutina. Las sesiones anteriores creadas por la rutina permanecen en su lista de sesiones.

306 308

307### Repositorios y permisos de rama309### Repositorios y permisos de rama

310 312

311Cada repositorio que agregue se clona en cada ejecución. Claude comienza desde la rama predeterminada del repositorio a menos que su prompt especifique lo contrario.313Cada repositorio que agregue se clona en cada ejecución. Claude comienza desde la rama predeterminada del repositorio a menos que su prompt especifique lo contrario.

312 314

313De forma predeterminada, Claude solo puede insertar en ramas con prefijo `claude/`. Esto evita que las rutinas modifiquen accidentalmente ramas protegidas o de larga duración. Para eliminar esta restricción para un repositorio específico, habilite **Permitir inserciones de rama sin restricciones** para ese repositorio al crear o editar la rutina.315De forma predeterminada, Claude solo puede insertar en ramas con prefijo `claude/`. Esto evita que las rutinas modifiquen accidentalmente ramas protegidas o de larga duración. Para eliminar esta restricción para un repositorio específico, habilite **Allow unrestricted branch pushes** para ese repositorio al crear o editar la rutina.

314 316

315### Conectores317### Conectores

316 318

318 320

319Cuando crea una rutina, todos sus conectores actualmente conectados se incluyen de forma predeterminada. Elimine cualquiera que no sea necesario para limitar a qué herramientas tiene acceso Claude durante la ejecución. También puede agregar conectores directamente desde el formulario de rutina.321Cuando crea una rutina, todos sus conectores actualmente conectados se incluyen de forma predeterminada. Elimine cualquiera que no sea necesario para limitar a qué herramientas tiene acceso Claude durante la ejecución. También puede agregar conectores directamente desde el formulario de rutina.

320 322

321Para administrar o agregar conectores fuera del formulario de rutina, visite **Configuración > Conectores** en claude.ai o use `/schedule update` en la CLI.323Para administrar o agregar conectores fuera del formulario de rutina, visite **Settings > Connectors** en claude.ai o use `/schedule update` en la CLI.

322 324

323### Entornos y acceso a la red325### Entornos y acceso a la red

324 326

325Cada rutina se ejecuta en un [entorno en la nube](/es/claude-code-on-the-web#the-cloud-environment) que controla el acceso a la red, variables de entorno y scripts de configuración. La rutina hereda la política de red del entorno en cada ejecución.327Cada rutina se ejecuta en un [entorno en la nube](/es/claude-code-on-the-web#the-cloud-environment) que controla el acceso a la red, variables de entorno y scripts de configuración. La rutina hereda la política de red del entorno en cada ejecución.

326 328

327El entorno **Default** utiliza acceso a la red **Trusted**: la [lista de permitidos predeterminada](/es/claude-code-on-the-web#default-allowed-domains) de registros de paquetes, API de proveedores de nube, registros de contenedores y dominios de desarrollo comunes es accesible, pero los dominios arbitrarios no. Las solicitudes salientes a otros hosts fallan con `403` y `x-deny-reason: host_not_allowed`. El tráfico del conector MCP se enruta a través de los servidores de Anthropic, por lo que los conectores que agregue a la rutina funcionan sin agregar sus hosts a **Dominios permitidos**. Elimine cualquier conector que no necesite en [Conectores](#conectores).329El entorno **Default** utiliza acceso a la red **Trusted**: la [lista de permitidos predeterminada](/es/claude-code-on-the-web#default-allowed-domains) de registros de paquetes, API de proveedores de nube, registros de contenedores y dominios de desarrollo comunes es accesible, pero los dominios arbitrarios no. Las solicitudes salientes a otros hosts fallan con `403` y `x-deny-reason: host_not_allowed`. El tráfico del conector MCP se enruta a través de los servidores de Anthropic, por lo que los conectores que agregue a la rutina funcionan sin agregar sus hosts a **Allowed domains**. Elimine cualquier conector que no necesite en [Conectores](#conectores).

328 330

329Para permitir dominios adicionales:331Para permitir dominios adicionales:

330 332

331<Steps>333<Steps>

332 <Step title="Abra la rutina para editar">334 <Step title="Abra la rutina para editar">

333 En la página de detalles de la rutina, haga clic en el icono de lápiz para abrir **Editar rutina**.335 En la página de detalles de la rutina, haga clic en el icono de lápiz para abrir **Edit routine**.

334 </Step>336 </Step>

335 337

336 <Step title="Abra el selector de entorno">338 <Step title="Abra el selector de entorno">

337 Debajo del cuadro **Instrucciones**, seleccione el icono de nube que muestra el nombre de su entorno, como **Default**.339 Debajo del cuadro **Instructions**, seleccione el icono de nube que muestra el nombre de su entorno, como **Default**.

338 </Step>340 </Step>

339 341

340 <Step title="Abra la configuración del entorno">342 <Step title="Abra la configuración del entorno">

342 </Step>344 </Step>

343 345

344 <Step title="Cambie el nivel de acceso a la red">346 <Step title="Cambie el nivel de acceso a la red">

345 En el diálogo **Actualizar entorno en la nube**, cambie **Acceso a la red** a **Personalizado** e ingrese sus dominios en **Dominios permitidos**. Marque **También incluir lista predeterminada de administradores de paquetes comunes** para mantener la [lista de permitidos predeterminada](/es/claude-code-on-the-web#default-allowed-domains) junto con sus dominios personalizados. Seleccione **Completo** en su lugar para acceso sin restricciones.347 En el diálogo **Update cloud environment**, cambie **Network access** a **Custom** e ingrese sus dominios en **Allowed domains**. Marque **Also include default list of common package managers** para mantener la [lista de permitidos predeterminada](/es/claude-code-on-the-web#default-allowed-domains) junto con sus dominios personalizados. Seleccione **Full** en su lugar para acceso sin restricciones.

346 </Step>348 </Step>

347 349

348 <Step title="Guardar">350 <Step title="Guardar">

349 Haga clic en **Guardar cambios**. La nueva política se aplica desde la próxima ejecución.351 Haga clic en **Save changes**. La nueva política se aplica desde la próxima ejecución.

350 </Step>352 </Step>

351</Steps>353</Steps>

352 354

353Consulte [Acceso a la red](/es/claude-code-on-the-web#network-access) para obtener detalles sobre los niveles de acceso y la lista de permitidos predeterminada.355Consulte [Network access](/es/claude-code-on-the-web#network-access) para obtener detalles sobre los niveles de acceso y la lista de permitidos predeterminada.

354 356

355## Uso y límites357## Uso y límites

356 358

357Las rutinas reducen el uso de suscripción de la misma manera que lo hacen las sesiones interactivas. Además de los límites de suscripción estándar, las rutinas tienen un límite diario de cuántas ejecuciones pueden comenzar por cuenta. Vea su consumo actual y ejecuciones diarias de rutina restantes en [claude.ai/code/routines](https://claude.ai/code/routines) o [claude.ai/settings/usage](https://claude.ai/settings/usage).359Las rutinas reducen el uso de suscripción de la misma manera que lo hacen las sesiones interactivas. Además de los límites de suscripción estándar, las rutinas tienen un límite diario de cuántas ejecuciones pueden comenzar por cuenta. Vea su consumo actual y ejecuciones diarias de rutina restantes en [claude.ai/code/routines](https://claude.ai/code/routines) o [claude.ai/settings/usage](https://claude.ai/settings/usage).

358 360

359Cuando una rutina alcanza el límite diario o el límite de uso de su suscripción, las organizaciones con uso adicional habilitado pueden continuar ejecutando rutinas en exceso medido. Sin uso adicional, las ejecuciones adicionales se rechazan hasta que se reinicia la ventana. Habilite el uso adicional desde **Configuración > Facturación** en claude.ai.361Cuando una rutina alcanza el límite diario o el límite de uso de su suscripción, las organizaciones con uso adicional habilitado pueden continuar ejecutando rutinas en exceso medido. Sin uso adicional, las ejecuciones adicionales se rechazan hasta que se reinicia la ventana. Habilite el uso adicional desde **Settings > Billing** en claude.ai.

360 362

361Las ejecuciones únicas no cuentan contra el límite diario de ejecuciones de rutina. Reducen su uso de suscripción regular como cualquier otra sesión, pero están exentas de la asignación diaria de ejecuciones de rutina por cuenta.363Las ejecuciones únicas no cuentan contra el límite diario de ejecuciones de rutina. Reducen su uso de suscripción regular como cualquier otra sesión, pero están exentas de la asignación diaria de ejecuciones de rutina por cuenta.

362 364

365## Solución de problemas

366

367### "Routines are disabled by your organization's policy"

368

369Su administrador de Team o Enterprise probablemente ha desactivado el botón de alternancia **Routines** en [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code). Esta es una configuración de organización del lado del servidor, por lo que no se puede anular desde su configuración local. Póngase en contacto con su administrador para solicitar que se habiliten las rutinas para su organización.

370

363## Recursos relacionados371## Recursos relacionados

364 372

365* [`/loop` e programación en sesión](/es/scheduled-tasks): programe tareas locales dentro de una sesión de CLI abierta373* [`/loop` e programación en sesión](/es/scheduled-tasks): programe tareas locales dentro de una sesión de CLI abierta

security.md +1 −1

Details

59* **Aprobación de solicitudes de red**: Las herramientas que realizan solicitudes de red requieren aprobación del usuario de forma predeterminada59* **Aprobación de solicitudes de red**: Las herramientas que realizan solicitudes de red requieren aprobación del usuario de forma predeterminada

60* **Ventanas de contexto aisladas**: La obtención web utiliza una ventana de contexto separada para evitar inyectar solicitudes potencialmente maliciosas60* **Ventanas de contexto aisladas**: La obtención web utiliza una ventana de contexto separada para evitar inyectar solicitudes potencialmente maliciosas

61* **Verificación de confianza**: Las primeras ejecuciones de base de código y los nuevos servidores MCP requieren verificación de confianza61* **Verificación de confianza**: Las primeras ejecuciones de base de código y los nuevos servidores MCP requieren verificación de confianza

~~62 * Nota: La verificación de confianza está deshabilitada cuando se ejecuta de forma no interactiva con la bandera `-p`~~62 * Nota: La verificación de confianza está deshabilitada cuando se ejecuta de forma no interactiva con la bandera `-p`. La excepción es [`--worktree`](/es/worktrees), que aún requiere que la confianza haya sido aceptada para el directorio

63* **Detección de inyección de comandos**: Los comandos bash sospechosos requieren aprobación manual incluso si fueron permitidos previamente63* **Detección de inyección de comandos**: Los comandos bash sospechosos requieren aprobación manual incluso si fueron permitidos previamente

64* **Coincidencia de cierre seguro**: Los comandos no coincidentes se establecen de forma predeterminada para requerir aprobación manual64* **Coincidencia de cierre seguro**: Los comandos no coincidentes se establecen de forma predeterminada para requerir aprobación manual

65* **Descripciones en lenguaje natural**: Los comandos bash complejos incluyen explicaciones para la comprensión del usuario65* **Descripciones en lenguaje natural**: Los comandos bash complejos incluyen explicaciones para la comprensión del usuario

server-managed-settings.md +3 −2

Details

41 </Step>41 </Step>

42 42

43 <Step title="Definir su configuración">43 <Step title="Definir su configuración">

44 Agregue su configuración como JSON. Todas las [configuraciones disponibles en `settings.json`](/es/settings#available-settings) son compatibles, incluidos [hooks](/es/hooks), [variables de entorno](/es/env-vars) y [configuraciones solo administradas](/es/permissions#managed-only-settings) como `allowManagedPermissionRulesOnly`.44 Agregue su configuración como JSON. Todas las [configuraciones disponibles en `settings.json`](/es/settings#available-settings) son compatibles excepto las restringidas a la entrega de políticas a nivel del sistema operativo; consulte [Limitaciones actuales](#current-limitations) para esa lista breve. Esto incluye [hooks](/es/hooks), [variables de entorno](/es/env-vars) y [configuraciones solo administradas](/es/permissions#managed-only-settings) como `allowManagedPermissionRulesOnly`.

45 45

46 Este ejemplo aplica una lista de denegación de permisos, impide que los usuarios omitan permisos y restringe las reglas de permisos a las definidas en la configuración administrada:46 Este ejemplo aplica una lista de denegación de permisos, impide que los usuarios omitan permisos y restringe las reglas de permisos a las definidas en la configuración administrada:

47 47

93 }93 }

94 ```94 ```

95 95

96 Debido a que los hooks ejecutan comandos de shell, los usuarios ven un [diálogo de aprobación de seguridad](#security-approval-dialogs) antes de que se apliquen. Consulte [Configurar el modo automático](/es/auto-mode-config) para ver cómo las entradas de `autoMode` afectan lo que el clasificador bloquea y advertencias importantes sobre los campos `allow` y `soft_deny`.96 Debido a que los hooks ejecutan comandos de shell, los usuarios ven un [diálogo de aprobación de seguridad](#security-approval-dialogs) antes de que se apliquen. Consulte [Configurar el modo automático](/es/auto-mode-config) para ver cómo las entradas de `autoMode` afectan lo que el clasificador bloquea y advertencias importantes sobre los campos `environment`, `allow`, `soft_deny` y `hard_deny`.

97 </Step>97 </Step>

98 98

99 <Step title="Guardar e implementar">99 <Step title="Guardar e implementar">

124 124

125* La configuración se aplica uniformemente a todos los usuarios de la organización. Las configuraciones por grupo aún no son compatibles.125* La configuración se aplica uniformemente a todos los usuarios de la organización. Las configuraciones por grupo aún no son compatibles.

126* Las [configuraciones de servidor MCP](/es/mcp#managed-mcp-configuration) no se pueden distribuir a través de la configuración administrada por servidor.126* Las [configuraciones de servidor MCP](/es/mcp#managed-mcp-configuration) no se pueden distribuir a través de la configuración administrada por servidor.

127* Las configuraciones restringidas a fuentes de políticas a nivel del sistema operativo, como `policyHelper` y `wslInheritsWindowsSettings`, no se respetan. Impleméntelas a través de MDM o un archivo `managed-settings.json` del sistema en su lugar.

127 128

128## Entrega de configuración129## Entrega de configuración

129 130

settings.md +28 −1

Details

169| `attribution` | Personalizar atribución para commits de git y solicitudes de extracción. Consulte [Configuración de atribución](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |169| `attribution` | Personalizar atribución para commits de git y solicitudes de extracción. Consulte [Configuración de atribución](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |

170| `autoMemoryDirectory` | Directorio personalizado para almacenamiento de [memoria automática](/es/memory#storage-location). Acepta una ruta absoluta o una ruta con prefijo `~/`. Se acepta desde configuraciones de política y usuario, y desde la bandera `--settings`. No se acepta desde configuraciones de proyecto o local, ya que un repositorio clonado podría proporcionar cualquiera de los archivos para redirigir escrituras de memoria a ubicaciones sensibles | `"~/my-memory-dir"` |170| `autoMemoryDirectory` | Directorio personalizado para almacenamiento de [memoria automática](/es/memory#storage-location). Acepta una ruta absoluta o una ruta con prefijo `~/`. Se acepta desde configuraciones de política y usuario, y desde la bandera `--settings`. No se acepta desde configuraciones de proyecto o local, ya que un repositorio clonado podría proporcionar cualquiera de los archivos para redirigir escrituras de memoria a ubicaciones sensibles | `"~/my-memory-dir"` |

171| `autoMemoryEnabled` | Habilitar [memoria automática](/es/memory#enable-or-disable-auto-memory). Cuando es `false`, Claude no lee ni escribe en el directorio de memoria automática. Predeterminado: `true`. También puede alternar esto con `/memory` durante una sesión. Para deshabilitar a través de variable de entorno, establezca [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/es/env-vars) en `env` | `false` |171| `autoMemoryEnabled` | Habilitar [memoria automática](/es/memory#enable-or-disable-auto-memory). Cuando es `false`, Claude no lee ni escribe en el directorio de memoria automática. Predeterminado: `true`. También puede alternar esto con `/memory` durante una sesión. Para deshabilitar a través de variable de entorno, establezca [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/es/env-vars) en `env` | `false` |

172| `autoMode` | Personalizar qué bloquea y permite el clasificador de [modo automático](/es/permission-modes#eliminate-prompts-with-auto-mode). Contiene matrices `environment`, `allow` y `soft_deny` de reglas en prosa. Incluya la cadena literal `"$defaults"` en una matriz para heredar las reglas integradas en esa posición. Consulte [Configurar modo automático](/es/auto-mode-config). No se lee desde configuraciones de proyecto compartidas | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |172| `autoMode` | Personalizar qué bloquea y permite el clasificador de [modo automático](/es/permission-modes#eliminate-prompts-with-auto-mode). Contiene matrices `environment`, `allow`, `soft_deny` y `hard_deny` de reglas en prosa. Incluya la cadena literal `"$defaults"` en una matriz para heredar las reglas integradas en esa posición. Consulte [Configurar modo automático](/es/auto-mode-config). No se lee desde configuraciones de proyecto compartidas | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |

173| `autoScrollEnabled` | En [renderizado de pantalla completa](/es/fullscreen), seguir la nueva salida hasta el final de la conversación. Predeterminado: `true`. Aparece en `/config` como **Auto-scroll**. Los avisos de permiso aún se desplazan a la vista cuando esto está desactivado | `false` |173| `autoScrollEnabled` | En [renderizado de pantalla completa](/es/fullscreen), seguir la nueva salida hasta el final de la conversación. Predeterminado: `true`. Aparece en `/config` como **Auto-scroll**. Los avisos de permiso aún se desplazan a la vista cuando esto está desactivado | `false` |

174| `autoUpdatesChannel` | Canal de lanzamiento a seguir para actualizaciones. Use `"stable"` para una versión que típicamente tiene aproximadamente una semana de antigüedad y omite versiones con regresiones importantes, o `"latest"` (predeterminado) para el lanzamiento más reciente. Para deshabilitar completamente las actualizaciones automáticas, establezca [`DISABLE_AUTOUPDATER`](/es/setup#disable-auto-updates) en `env` | `"stable"` |174| `autoUpdatesChannel` | Canal de lanzamiento a seguir para actualizaciones. Use `"stable"` para una versión que típicamente tiene aproximadamente una semana de antigüedad y omite versiones con regresiones importantes, o `"latest"` (predeterminado) para el lanzamiento más reciente. Para deshabilitar completamente las actualizaciones automáticas, establezca [`DISABLE_AUTOUPDATER`](/es/setup#disable-auto-updates) en `env` | `"stable"` |

175| `availableModels` | Restringir qué modelos pueden seleccionar los usuarios a través de `/model`, `--model`, o `ANTHROPIC_MODEL`. No afecta la opción Predeterminado. Consulte [Restringir selección de modelo](/es/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |175| `availableModels` | Restringir qué modelos pueden seleccionar los usuarios a través de `/model`, `--model`, o `ANTHROPIC_MODEL`. No afecta la opción Predeterminado. Consulte [Restringir selección de modelo](/es/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |

216| `plansDirectory` | Personalizar dónde se almacenan los archivos de plan. La ruta es relativa a la raíz del proyecto. Predeterminado: `~/.claude/plans` | `"./plans"` |216| `plansDirectory` | Personalizar dónde se almacenan los archivos de plan. La ruta es relativa a la raíz del proyecto. Predeterminado: `~/.claude/plans` | `"./plans"` |

217| `pluginTrustMessage` | (Solo configuraciones administradas) Mensaje personalizado agregado a la advertencia de confianza de plugin mostrada antes de la instalación. Use esto para agregar contexto específico de la organización, por ejemplo para confirmar que los plugins de su marketplace interno están verificados. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Solo configuraciones administradas) Mensaje personalizado agregado a la advertencia de confianza de plugin mostrada antes de la instalación. Use esto para agregar contexto específico de la organización, por ejemplo para confirmar que los plugins de su marketplace interno están verificados. | `"All plugins from our marketplace are approved by IT"` |

218| `policyHelper` | {/* min-version: 2.1.136 */}Ejecutable implementado por administrador que calcula configuraciones administradas dinámicamente al inicio. Solo se honra desde MDM o un archivo `managed-settings.json` del sistema. Consulte [Calcular configuraciones administradas con un asistente de política](#compute-managed-settings-with-a-policy-helper). Requiere Claude Code v2.1.136 o posterior | `{"path": "/usr/local/bin/claude-policy"}` |

218| `preferredNotifChannel` | Método para notificaciones de tarea completada y solicitud de permiso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predeterminado: `"auto"`, que envía una notificación de escritorio en iTerm2, Ghostty y Kitty y no hace nada en otras terminales. Establezca `"terminal_bell"` para sonar el carácter de campana en cualquier terminal. Aparece en `/config` como **Notifications**. Consulte [Obtener una campana de terminal o notificación](/es/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |219| `preferredNotifChannel` | Método para notificaciones de tarea completada y solicitud de permiso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predeterminado: `"auto"`, que envía una notificación de escritorio en iTerm2, Ghostty y Kitty y no hace nada en otras terminales. Establezca `"terminal_bell"` para sonar el carácter de campana en cualquier terminal. Aparece en `/config` como **Notifications**. Consulte [Obtener una campana de terminal o notificación](/es/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |

220| `prUrlTemplate` | Plantilla de URL para la insignia de PR mostrada en el pie de página y en resúmenes de resultados de herramientas. Sustituye `{host}`, `{owner}`, `{repo}`, `{number}` y `{url}` de la URL de PR reportada por `gh`. Use para apuntar enlaces de PR a una herramienta de revisión de código interna en lugar de `github.com`. No afecta autolinks `#123` en la prosa de Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |221| `prUrlTemplate` | Plantilla de URL para la insignia de PR mostrada en el pie de página y en resúmenes de resultados de herramientas. Sustituye `{host}`, `{owner}`, `{repo}`, `{number}` y `{url}` de la URL de PR reportada por `gh`. Use para apuntar enlaces de PR a una herramienta de revisión de código interna en lugar de `github.com`. No afecta autolinks `#123` en la prosa de Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |

470}471}

471```472```

472 473

474### Calcular configuraciones administradas con un asistente de política

475

476La configuración `policyHelper` apunta a un ejecutable que calcula configuraciones administradas al inicio, para que los administradores puedan derivar política de postura de dispositivo, identidad, o un servicio remoto en lugar de un archivo estático. Configúrelo desde MDM o un archivo `managed-settings.json` del sistema. Claude Code ignora `policyHelper` cuando aparece en cualquier otro ámbito, incluyendo configuraciones de usuario, configuraciones de proyecto, el hive de registro HKCU, y [configuraciones administradas por servidor](/es/server-managed-settings).

477

478La configuración acepta estas claves:

479

480| Clave | Tipo | Descripción |

481| ------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------- |

482| `path` | string | Ruta absoluta al ejecutable del asistente |

483| `timeoutMs` | number | Cuánto tiempo esperar al asistente antes de tratar la ejecución como fallida |

484| `refreshIntervalMs` | number | Con qué frecuencia re-ejecutar el asistente en segundo plano. Establezca en `0` para deshabilitar la actualización, o en al menos `60000` |

485

486El asistente escribe una envoltura JSON a stdout. Ponga las configuraciones bajo una clave `managedSettings` en lugar de en el nivel superior, ya que un objeto de configuraciones desnudo se analiza con `managedSettings` indefinido y no aplica nada:

487

488```json theme={null}

489{

490 "managedSettings": {

491 "permissions": { "deny": ["Read(//etc/secrets/**)"] }

492 },

493 "claudeMd": "# Organization context\n...",

494 "appendSystemPrompt": "Always cite the internal style guide."

495}

496```

497

498Cuando el asistente emite `managedSettings`, ese objeto reemplaza las configuraciones administradas basadas en archivos para la ejecución. Cuando el asistente sale con código no cero al inicio, Claude Code imprime el error y se niega a iniciar, por lo que un asistente que necesita resiliencia de interrupción debe servir desde su propio caché y salir con `0`.

499

473### Precedencia de configuración500### Precedencia de configuración

474 501

475Las configuraciones se aplican en orden de precedencia. De mayor a menor:502Las configuraciones se aplican en orden de precedencia. De mayor a menor:

whats-new.md +17 −1

Details

8 8

9El resumen semanal para desarrolladores destaca las características más propensas a cambiar la forma en que trabaja. Cada entrada incluye código ejecutable, una breve demostración y un enlace a la documentación completa. Para cada corrección de errores y mejora menor, consulte el [registro de cambios](/es/changelog).9El resumen semanal para desarrolladores destaca las características más propensas a cambiar la forma en que trabaja. Cada entrada incluye código ejecutable, una breve demostración y un enlace a la documentación completa. Para cada corrección de errores y mejora menor, consulte el [registro de cambios](/es/changelog).

10 10

11<Update label="Week 19" description="May 4–8, 2026" tags={["v2.1.128–v2.1.136"]}>

12 **Los plugins se cargan desde archivos `.zip` y URLs**: `--plugin-dir` ahora acepta archivos `.zip`, y `--plugin-url` obtiene un archivo de plugin para la sesión actual.

14 También esta semana: **`worktree.baseRef`** elige si los nuevos worktrees se ramifican desde el remoto predeterminado o desde `HEAD` local; **reglas de negación dura en modo automático** bloquean acciones incondicionalmente independientemente de excepciones de permiso; y **los hooks ven el nivel de esfuerzo activo** a través de `effort.level` y `$CLAUDE_EFFORT`.

16 [Lea el resumen de la Week 19 →](/es/whats-new/2026-w19)

17</Update>

19<Update label="Week 18" description="April 27 – May 1, 2026" tags={["v2.1.120–v2.1.126"]}>

20 **Windows sin Git Bash**: Git para Windows ya no es necesario, y Claude Code usa PowerShell como herramienta de shell cuando Bash no está disponible.

22 También esta semana: **`claude ultrareview`** trae revisión de código en la nube a CI y scripts; **`claude project purge`** limpia el estado local de un proyecto; y pegar una **URL de PR en `/resume`** encuentra la sesión que la creó.

24 [Lea el resumen de la Week 18 →](/es/whats-new/2026-w18)

25</Update>

11<Update label="Week 17" description="April 20–24, 2026" tags={["v2.1.114–v2.1.119"]}>27<Update label="Week 17" description="April 20–24, 2026" tags={["v2.1.114–v2.1.119"]}>

12 **`/ultrareview`** se abre como una vista previa de investigación pública: una flota de agentes cazadores de errores se ejecuta en la nube y los hallazgos llegan automáticamente a su CLI o Desktop.28 **`/ultrareview`** se abre como una vista previa de investigación pública: una flota de agentes cazadores de errores se ejecuta en la nube y los hallazgos llegan automáticamente a su CLI o Desktop.

13 29

19<Update label="Week 16" description="April 13–17, 2026" tags={["v2.1.105–v2.1.113"]}>35<Update label="Week 16" description="April 13–17, 2026" tags={["v2.1.105–v2.1.113"]}>

20 **Claude Opus 4.7** llega como el nuevo predeterminado en Max y Team Premium, con un nuevo nivel de esfuerzo `xhigh` que es la configuración recomendada para la mayoría del trabajo de codificación y un control deslizante interactivo `/effort` para ajustarlo.36 **Claude Opus 4.7** llega como el nuevo predeterminado en Max y Team Premium, con un nuevo nivel de esfuerzo `xhigh` que es la configuración recomendada para la mayoría del trabajo de codificación y un control deslizante interactivo `/effort` para ajustarlo.

21 37

22 También esta semana: **Routines** en Claude Code en la web disparan agentes en la nube con plantillas desde una programación, evento de GitHub o llamada API; `/ultrareview` ejecuta revisión de código multiagente paralela en la nube; `/usage` muestra qué está impulsando sus límites; y la CLI se traslada a binarios nativos.38 También esta semana: **Routines** en Claude Code en la web disparan agentes en la nube con plantillas desde una programación, evento de GitHub o llamada API; **notificaciones push móviles** le avisan a su teléfono cuando una tarea larga finaliza o Claude lo necesita; `/usage` muestra qué está impulsando sus límites; y la CLI se traslada a binarios nativos.

23 39

24 [Lea el resumen de la Week 16 →](/es/whats-new/2026-w16)40 [Lea el resumen de la Week 16 →](/es/whats-new/2026-w16)

25</Update>41</Update>

whats-new/2026-w16.md +11 −13

Details

4 4

5# Semana 16 · 13–17 de abril de 20265# Semana 16 · 13–17 de abril de 2026

6 6

7> Claude Opus 4.7 con el nuevo nivel de esfuerzo xhigh, Routines en Claude Code en la web, /ultrareview revisión de código en la nube, un desglose de /usage que muestra qué está impulsando sus límites, y binarios nativos reemplazando el JavaScript empaquetado.7> Claude Opus 4.7 con el nuevo nivel de esfuerzo xhigh, Routines en Claude Code en la web, notificaciones push móviles que alertan a su teléfono cuando Claude lo necesita, un desglose de /usage que muestra qué está impulsando sus límites, y binarios nativos reemplazando el JavaScript empaquetado.

8 8

9<div className="digest-meta">9<div className="digest-meta">

10 <span>Releases <a href="/docs/es/changelog#2-1-105">v2.1.105 → v2.1.113</a></span>10 <span>Releases <a href="/docs/es/changelog#2-1-105">v2.1.105 → v2.1.113</a></span>

73 73

74<div className="digest-feature">74<div className="digest-feature">

75 <div className="digest-feature-header">75 <div className="digest-feature-header">

~~76 <span className="digest-feature-title">/ultrareview</span>~~76 <span className="digest-feature-title">Notificaciones push móviles</span>

~~77 <span className="digest-feature-pill">v2.1.111</span>~~77 <span className="digest-feature-pill">móvil</span>

78 </div>78 </div>

79 79

80 <p className="digest-feature-lede">Revisión de código integral en la nube. Ultrareview expande su rama en múltiples revisores paralelos en Claude Code en la web, ejecuta una pasada de crítica adversarial sobre cada hallazgo y devuelve un informe de hallazgos verificados mientras su terminal permanece libre. Llámelo sin argumentos para revisar su rama actual, o pase un número de PR para obtener y revisar ese PR. El diálogo de lanzamiento ahora muestra un diffstat para que sepa qué está subiendo antes de confirmar.</p>80 <p className="digest-feature-lede">Con <a href="/docs/es/remote-control">Control remoto</a> conectado, Claude puede enviar una notificación push a su teléfono cuando una tarea larga finaliza o necesita una decisión para continuar. Actívelo con "Enviar cuando Claude lo decida" en <code>/config</code>, o solicite uno en su prompt. Útil cuando inicia una ejecución de agente larga y desea alejarse de la terminal.</p>

81 81

~~82 <p className="digest-feature-try">Revise la rama en la que se encuentra:</p>~~82 <Frame>

83 83 <video autoPlay muted loop playsInline className="w-full" src="https://mintcdn.com/claude-code/uII1TETOZxBUZ3lB/images/whats-new/push-notifications.mp4?fit=max&auto=format&n=uII1TETOZxBUZ3lB&q=85&s=c91a967139596500cbdb581a53822ac1" data-path="images/whats-new/push-notifications.mp4" />

~~84 ```text Claude Code theme={null}~~84 </Frame>

~~85 > /ultrareview~~

~~86 ```~~

87 85

~~88 <p className="digest-feature-try">O apúntelo a un PR:</p>~~86 <p className="digest-feature-try">Pida a Claude que le avise cuando haya terminado:</p>

89 87

90 ```text Claude Code theme={null}88 ```text Claude Code theme={null}

~~91 > /ultrareview 1234~~89 > notify me when the tests pass

92 ```90 ```

93 91

~~94 <a className="digest-feature-link" href="/docs/es/ultrareview">Guía de Ultrareview</a>~~92 <a className="digest-feature-link" href="/docs/es/remote-control#mobile-push-notifications">Control remoto: notificaciones push móviles</a>

95</div>93</div>

96 94

97<div className="digest-feature">95<div className="digest-feature">

116 <p className="digest-wins-title">Otros logros</p>114 <p className="digest-wins-title">Otros logros</p>

117 115

118 <div className="digest-wins-grid">116 <div className="digest-wins-grid">

117 <div>Nuevo <a href="/docs/es/ultrareview"><code>/ultrareview</code></a>: revisión de código integral en la nube utilizando análisis paralelo de múltiples agentes y una pasada de crítica adversarial. Ejecútelo sin argumentos para revisar su rama actual, o <code>/ultrareview \<PR#></code> para un PR específico</div>

119 <div><a href="/docs/es/permission-modes#eliminate-prompts-with-auto-mode">Modo automático</a> ahora está disponible para suscriptores de Max en Opus 4.7, y la bandera <code>--enable-auto-mode</code> ya no es necesaria</div>118 <div><a href="/docs/es/permission-modes#eliminate-prompts-with-auto-mode">Modo automático</a> ahora está disponible para suscriptores de Max en Opus 4.7, y la bandera <code>--enable-auto-mode</code> ya no es necesaria</div>

120 <div><a href="/docs/es/interactive-mode#session-recap">Resumen de sesión</a> muestra un resumen de una línea de lo que sucedió mientras estaba fuera; ejecute <code>/recap</code> bajo demanda o desactívelo desde <code>/config</code></div>119 <div><a href="/docs/es/interactive-mode#session-recap">Resumen de sesión</a> muestra un resumen de una línea de lo que sucedió mientras estaba fuera; ejecute <code>/recap</code> bajo demanda o desactívelo desde <code>/config</code></div>

121 <div>Nuevo comando <code>/tui</code> y configuración <code>tui</code> cambian entre renderizado clásico y sin parpadeos a mitad de la conversación; la vista de enfoque se movió de <code>Ctrl+O</code> a su propio comando <code>/focus</code></div>120 <div>Nuevo comando <code>/tui</code> y configuración <code>tui</code> cambian entre renderizado clásico y sin parpadeos a mitad de la conversación; la vista de enfoque se movió de <code>Ctrl+O</code> a su propio comando <code>/focus</code></div>

122 <div>Herramienta de notificación push: con <a href="/docs/es/remote-control">Control remoto</a> conectado y "Enviar cuando Claude lo decida" habilitado, Claude puede hacer ping a su teléfono cuando lo necesita</div>

123 <div>Los plugins pueden enviar observadores de fondo a través de una clave de manifiesto de nivel superior <code>monitors</code> que se arma automáticamente al inicio de la sesión o en la invocación de habilidades</div>121 <div>Los plugins pueden enviar observadores de fondo a través de una clave de manifiesto de nivel superior <code>monitors</code> que se arma automáticamente al inicio de la sesión o en la invocación de habilidades</div>

124 <div>Opción "Automático (coincidir terminal)" en <code>/theme</code> sigue el modo oscuro/claro de su terminal</div>122 <div>Opción "Automático (coincidir terminal)" en <code>/theme</code> sigue el modo oscuro/claro de su terminal</div>

125 <div><code>/fewer-permission-prompts</code> escanea sus transcripciones en busca de llamadas comunes de Bash y MCP de solo lectura y propone una lista de permitidos para <code>.claude/settings.json</code></div>123 <div><code>/fewer-permission-prompts</code> escanea sus transcripciones en busca de llamadas comunes de Bash y MCP de solo lectura y propone una lista de permitidos para <code>.claude/settings.json</code></div>

whats-new/2026-w18.md +113 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Semana 18 · 27 de abril – 1 de mayo de 2026

7> Claude Code en Windows se ejecuta sin Git Bash, claude auth login acepta un código OAuth pegado cuando la devolución de llamada del navegador no puede alcanzar localhost, claude project purge limpia el estado local por proyecto, y pegar una URL de PR en /resume encuentra la sesión que la creó.

9<div className="digest-meta">

10 <span>Releases <a href="/docs/es/changelog#2-1-120">v2.1.120 → v2.1.126</a></span>

11 <span>4 características · 27 de abril – 1 de mayo</span>

12</div>

14<div className="digest-feature">

15 <div className="digest-feature-header">

16 <span className="digest-feature-title">Iniciar sesión sin devolución de llamada del navegador</span>

17 <span className="digest-feature-pill">v2.1.126</span>

18 </div>

20 <p className="digest-feature-lede"><code>claude auth login</code> ahora acepta el código OAuth pegado directamente en la terminal cuando la devolución de llamada del navegador no puede alcanzar localhost. Esto cubre WSL2, sesiones SSH y contenedores, donde la redirección a un puerto local no funciona. La misma versión también corrige los tiempos de espera de inicio de sesión en conexiones lentas o con proxy y en devcontainers solo IPv6.</p>

22 <p className="digest-feature-try">Inicie sesión y luego pegue el código del navegador:</p>

24 ```bash theme={null}

25 claude auth login

26 ```

28 <a className="digest-feature-link" href="/docs/es/cli-reference#cli-commands">Referencia de CLI</a>

29</div>

31<div className="digest-feature">

32 <div className="digest-feature-header">

33 <span className="digest-feature-title">claude project purge</span>

34 <span className="digest-feature-pill">v2.1.126</span>

35 </div>

37 <p className="digest-feature-lede">Elimine todo el estado de Claude Code para un proyecto: transcripciones, tareas, historial de archivos y la entrada de configuración del proyecto. Admite `--dry-run` para obtener una vista previa, `-y`/`--yes` para omitir la confirmación, `-i`/`--interactive` para elegir, y `--all` para limpiar todos los proyectos.</p>

39 <p className="digest-feature-try">Obtenga una vista previa de lo que se eliminaría:</p>

41 ```bash theme={null}

42 claude project purge --dry-run

43 ```

45 <p className="digest-feature-try">Luego ejecútelo de verdad:</p>

47 ```bash theme={null}

48 claude project purge

49 ```

51 <a className="digest-feature-link" href="/docs/es/cli-reference">Referencia de CLI</a>

52</div>

54<div className="digest-feature">

55 <div className="digest-feature-header">

56 <span className="digest-feature-title">Reanudar por URL de PR</span>

57 <span className="digest-feature-pill">v2.1.122</span>

58 </div>

60 <p className="digest-feature-lede">Cuando crea una solicitud de extracción con <code>gh pr create</code>, Claude Code la vincula a la sesión que la produjo. Ahora puede volver a esa sesión solo desde la URL de PR, sin necesidad de recordar su nombre.</p>

62 <p className="digest-feature-try">Abra el selector de sesiones:</p>

64 ```text Claude Code theme={null}

65 > /resume

66 ```

68 <p className="digest-feature-try">Pegue la URL de PR en el selector. El primer carácter del pegado lo coloca en modo de búsqueda, y la lista se filtra a la sesión que creó ese PR. Presione Intro para reanudarlo. Las URL de solicitudes de extracción y fusión de GitHub, GitHub Enterprise, GitLab y Bitbucket funcionan todas.</p>

70 ```text Claude Code theme={null}

71 https://github.com/your-org/your-repo/pull/1234

72 ```

74 <p className="digest-feature-try">Para omitir el selector, pase el número de PR en la línea de comandos en su lugar:</p>

76 ```bash theme={null}

77 claude --from-pr 1234

78 ```

80 <a className="digest-feature-link" href="/docs/es/sessions#use-the-session-picker">Sesiones: usar el selector de sesiones</a>

81</div>

83<div className="digest-feature">

84 <div className="digest-feature-header">

85 <span className="digest-feature-title">Windows sin Git Bash</span>

86 <span className="digest-feature-pill">Windows</span>

87 </div>

89 <p className="digest-feature-lede">Git para Windows ya no es obligatorio. Cuando Bash no está presente, Claude Code usa PowerShell como herramienta de shell, y cuando la herramienta PowerShell está habilitada se trata como el shell principal. PowerShell 7 instalado a través de Microsoft Store, MSI sin PATH, o una herramienta global de <code>.NET</code> ahora se detecta automáticamente.</p>

91 <a className="digest-feature-link" href="/docs/es/setup">Guía de configuración</a>

92</div>

94<div className="digest-wins">

95 <p className="digest-wins-title">Otros logros</p>

97 <div className="digest-wins-grid">

98 <div>Los servidores MCP pueden optar por no participar en el aplazamiento de búsqueda de herramientas con <code>alwaysLoad: true</code> en su configuración para que todas las herramientas de ese servidor siempre estén disponibles</div>

99 <div>Nuevo <code>claude plugin prune</code> elimina dependencias de complementos instalados automáticamente huérfanos, y <code>plugin uninstall --prune</code> se propaga</div>

100 <div><code>/skills</code> ahora tiene un cuadro de búsqueda de escritura para filtrar para que pueda encontrar una habilidad en una lista larga sin desplazarse</div>

101 <div>Los hooks <code>PostToolUse</code> pueden reemplazar la salida de herramientas para cualquier herramienta a través de <code>hookSpecificOutput.updatedToolOutput</code>, no solo herramientas MCP</div>

102 <div>Nuevo subcomando <a href="/docs/es/ultrareview"><code>claude ultrareview</code></a> ejecuta <code>/ultrareview</code> de forma no interactiva desde CI o scripts: imprime hallazgos en stdout (<code>--json</code> para salida sin procesar) y sale con 0 al completarse o 1 en caso de fallo</div>

103 <div><code>--dangerously-skip-permissions</code> ahora omite las indicaciones para escrituras en <code>.claude/</code>, <code>.git/</code>, <code>.vscode/</code>, archivos de configuración de shell y otras rutas previamente protegidas, mientras que los comandos de eliminación catastrófica aún solicitan como red de seguridad</div>

104 <div>El selector <code>/model</code> puede enumerar modelos desde el punto final <code>/v1/models</code> de su puerta de enlace cuando <code>ANTHROPIC\_BASE\_URL</code> apunta a una puerta de enlace compatible con Anthropic; opte por <code>CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1</code> desde v2.1.129</div>

105 <div>Los servidores MCP que encuentran un error transitorio durante el inicio ahora se reintentan automáticamente hasta 3 veces en lugar de permanecer desconectados</div>

106 <div><code>ANTHROPIC\_BEDROCK\_SERVICE\_TIER</code> selecciona un nivel de servicio de Bedrock: <code>default</code>, <code>flex</code>, o <code>priority</code></div>

107 <div><code>/terminal-setup</code> habilita la configuración de acceso al portapapeles de iTerm2 para que <code>/copy</code> funcione, incluso desde tmux</div>

108 <div>Vertex AI ahora admite Federación de Identidad de Carga de Trabajo basada en certificados X.509 (mTLS ADC)</div>

109 <div>Correcciones significativas de fugas de memoria: sesiones con muchas imágenes, <code>/usage</code> en historiales de transcripción grandes, y herramientas de larga duración sin eventos de progreso</div>

110 </div>

111</div>

112

113[Registro de cambios completo para v2.1.120–v2.1.126 →](/es/changelog#2-1-120)

whats-new/2026-w19.md +60 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Semana 19 · 4–8 de mayo de 2026

7> Cargue plugins desde archivos .zip y URLs, busque en el historial de comandos en todos los proyectos con Ctrl+R, cree nuevas worktrees desde HEAD local o la rama predeterminada remota, y bloquee acciones incondicionalmente con reglas de negación dura en modo automático.

9<div className="digest-meta">

10 <span>Versiones <a href="/es/changelog#2-1-128">v2.1.128 → v2.1.136</a></span>

11 <span>2 características · 4–8 de mayo</span>

12</div>

14<div className="digest-feature">

15 <div className="digest-feature-header">

16 <span className="digest-feature-title">Plugins desde archivos .zip y URLs</span>

17 </div>

19 <p className="digest-feature-lede">`--plugin-dir` ahora acepta un archivo de plugin <code>.zip</code> además de un directorio, y la nueva bandera `--plugin-url` obtiene un archivo de plugin desde una URL para la sesión actual. Útil para probar un plugin antes de agregarlo a un marketplace, o para enviar plugins internos desde un almacén de artefactos.</p>

21 <p className="digest-feature-try">Cargue un plugin directamente desde una URL:</p>

23 ```bash terminal theme={null}

24 claude --plugin-url https://example.com/my-plugin.zip

25 ```

27 <a className="digest-feature-link" href="/es/plugins">Guía de plugins</a>

28</div>

30<div className="digest-feature">

31 <div className="digest-feature-header">

32 <span className="digest-feature-title">Búsqueda de historial en todos sus proyectos</span>

33 <span className="digest-feature-pill">v2.1.129</span>

34 </div>

36 <p className="digest-feature-lede"><code>Ctrl+R</code> la búsqueda inversa ahora se establece de forma predeterminada en todos los prompts en todos los proyectos, restaurando el comportamiento anterior a v2.1.124. Presione <code>Ctrl+S</code> mientras busca para reducir al proyecto o sesión actual. Útil cuando recuerda un comando que ejecutó en otro repositorio la semana pasada y no desea tener que buscarlo.</p>

38 <a className="digest-feature-link" href="/es/interactive-mode#command-history">Modo interactivo: historial de comandos</a>

39</div>

41<div className="digest-wins">

42 <p className="digest-wins-title">Otros logros</p>

44 <div className="digest-wins-grid">

45 <div>La nueva configuración <code>worktree.baseRef</code> (<code>fresh</code> | <code>head</code>) controla si <code>--worktree</code>, la herramienta <code>EnterWorktree</code> y las worktrees de aislamiento de agentes se ramifican desde la rama predeterminada remota o desde <code>HEAD</code> local; el valor predeterminado <code>fresh</code> mantiene los commits no enviados fuera de las nuevas worktrees</div>

46 <div>Las nuevas reglas <code>settings.autoMode.hard\_deny</code> bloquean acciones coincidentes incondicionalmente en modo automático, independientemente de las excepciones de permiso, para acciones que nunca deben ejecutarse automáticamente incluso cuando se aplican reglas de permiso más amplias</div>

47 <div>Los hooks ahora reciben el nivel de esfuerzo activo a través del campo de entrada JSON `effort.level` y la variable de entorno `$CLAUDE_EFFORT`, y los comandos de herramientas Bash pueden leer <code>\$CLAUDE\_EFFORT</code></div>

48 <div><code>CLAUDE\_CODE\_DISABLE\_ALTERNATE\_SCREEN=1</code> rechaza el renderizador de pantalla alternativa a pantalla completa y mantiene la conversación en el desplazamiento nativo de la terminal</div>

49 <div><code>CLAUDE\_CODE\_PACKAGE\_MANAGER\_AUTO\_UPDATE</code> permite que las instalaciones de Homebrew o WinGet ejecuten la actualización en segundo plano y soliciten reiniciar</div>

50 <div><code>CLAUDE\_CODE\_SESSION\_ID</code> ahora está en el entorno del subproceso de herramientas Bash, coincidiendo con el `session_id` pasado a los hooks</div>

51 <div><code>/mcp</code> ahora muestra el recuento de herramientas para servidores conectados e indica servidores que se conectaron con 0 herramientas</div>

52 <div><code>--channels</code> ahora funciona con autenticación de consola (clave API)</div>

53 <div>Los subprocesos como Bash, hooks, MCP y LSP ya no heredan variables de entorno <code>OTEL\_\*</code>, por lo que las aplicaciones instrumentadas con OTEL ejecutadas a través de la herramienta Bash ya no recogen el punto final OTLP propio de la CLI</div>

54 <div>Los resúmenes de progreso del subaagente ahora alcanzan el caché de prompts, reduciendo el costo de tokens de `cache_creation` aproximadamente 3 veces</div>

55 <div>Varias correcciones de confiabilidad de OAuth y credenciales: las sesiones paralelas ya no se atascan en 401 después de una carrera de token de actualización, los tokens de actualización de OAuth de MCP ya no se pierden cuando varios servidores se actualizan simultáneamente, y se corrige un raro bucle de inicio de sesión de una escritura de credencial concurrente</div>

56 <div>La nueva clave de administrador <code>parentSettingsBehavior</code> permite a los administradores optar por <code>managedSettings</code> del SDK en la fusión de políticas</div>

57 </div>

58</div>

60[Registro de cambios completo para v2.1.128–v2.1.136 →](/es/changelog#2-1-128)

Documentation 2026-05-08 22:00 UTC to 2026-05-09 04:57 UTC