Documentation — Spybara

agent-sdk/mcp.md +1 −1

Details

309 </Tab>309 </Tab>

310</Tabs>310</Tabs>

311 311

312Pour HTTP (non-streaming), utilisez `"type": "http"` à la place.312Pour le transport HTTP en continu, utilisez `"type": "http"` à la place. Dans `.mcp.json` et autres fichiers de configuration JSON, `"streamable-http"` est accepté comme alias pour `"http"`. L'option programmatique `mcpServers` accepte uniquement `"http"`.

313 313

314### Serveurs MCP SDK314### Serveurs MCP SDK

315 315

agent-sdk/python.md +4 −2

Details

2315 2315

2316**Nom de l'outil :** `AskUserQuestion`2316**Nom de l'outil :** `AskUserQuestion`

2317 2317

2318Pose des questions de clarification à l'utilisateur pendant l'exécution. Voir [Handle approvals and user input](/fr/agent-sdk/user-input#handle-clarifying-questions) pour les détails d'utilisation.2318Pose des questions de clarification à l'utilisateur pendant l'exécution. Voir [Gérer les approbations et les entrées utilisateur](/fr/agent-sdk/user-input#handle-clarifying-questions) pour les détails d'utilisation.

2319 2319

2320**Entrée :**2320**Entrée :**

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 +82 −0

Details

310 310

311### `resolveSettings()`

312

313Résout les paramètres Claude Code effectifs pour un répertoire donné en utilisant le même moteur de fusion que l'interface CLI, sans générer l'interface CLI Claude. Utilisez-le pour inspecter quelle configuration un appel `query()` verrait avant d'en invoquer un.

314

315<Note>

316 Cette fonction est en version alpha et son API peut changer avant la stabilisation. Elle lit les sources MDM, y compris la liste de propriétés macOS et Windows HKLM/HKCU, pour la parité avec le démarrage de l'interface CLI, mais n'exécute pas le sous-processus `policyHelper` configuré par l'administrateur. Le champ `permissions.defaultMode` est retourné tel quel de tous les niveaux, y compris les paramètres de projet. Le filtre de confiance que l'interface CLI applique avant d'honorer les modes de permission croissants n'est pas appliqué.

317</Note>

318

319```typescript theme={null}

320function resolveSettings(

321 options?: ResolveSettingsOptions

322): Promise<ResolvedSettings>;

323```

324

325#### Paramètres

326

327`resolveSettings()` accepte un seul objet d'options. Tous les champs sont optionnels.

328

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

332| `options.settingSources` | [`SettingSource`](#settingsource)`[]` | Toutes les sources | Quelles sources du système de fichiers charger. Passez `[]` pour ignorer les paramètres utilisateur, projet et locaux. Les paramètres de politique gérée se chargent dans tous les cas |

333| `options.managedSettings` | `Settings` | `undefined` | Paramètres de politique restrictive fusionnés au niveau de précédence de la politique gérée. Les clés non restrictives telles que `model` sont silencieusement supprimées |

335

336#### Type de retour : `ResolvedSettings`

337

338`resolveSettings()` retourne un objet décrivant les paramètres fusionnés et la source qui a contribué à chaque clé.

339

340| Propriété | Type | Description |

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

342| `effective` | `Settings` | Paramètres fusionnés après application de toutes les sources activées dans l'ordre de précédence |

343| `provenance` | `Partial<Record<keyof Settings, ProvenanceEntry>>` | Pour chaque clé de niveau supérieur dans `effective`, quelle source a fourni la valeur |

344| `sources` | `Array<{ source, settings, path?, policyOrigin? }>` | Paramètres bruts par source, ordonnés de la plus basse à la plus haute précédence |

345

346#### Exemple

347

348L'exemple ci-dessous résout les paramètres pour un répertoire de projet et imprime la source qui contrôle la période de nettoyage.

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## Types362## Types

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

1109Événement de flux émis quand le système de permissions refuse automatiquement un appel d'outil sans invite interactive. Utilisez-le pour afficher le refus dans votre interface utilisateur au fur et à mesure, plutôt que d'observer uniquement le résultat d'outil `is_error` qui suit. Le chemin de demande interactive atteint votre application séparément via le callback [`canUseTool`](#canusetool). Les refus émis par un hook `PreToolUse` ne sont pas signalés via cet événement.

1110

1111Cet événement nécessite Claude Code v2.1.136 ou ultérieur.

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| Champ | Type | Description |

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

1130| `tool_name` | `string` | Nom de l'outil qui a été refusé |

1131| `tool_use_id` | `string` | ID du bloc `tool_use` auquel ce refus répond |

1132| `agent_id` | `string` | ID du sous-agent quand l'appel refusé provient d'un sous-agent. Reflète le champ sur `can_use_tool` pour l'acheminement côté hôte |

1133| `decision_reason_type` | `string` | Discriminateur du composant qui a décidé, tel que `"rule"`, `"mode"`, `"classifier"` ou `"asyncAgent"` |

1134| `decision_reason` | `string` | Raison lisible par l'homme du composant décideur, quand disponible |

1135| `message` | `string` | Message de rejet retourné au modèle dans le `tool_result` |

1136

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

1056 1138

1057Informations sur une utilisation d'outil refusée.1139Informations sur une utilisation d'outil refusée.

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# Gérer les approbations et les entrées utilisateur

7> Présentez les demandes d'approbation et les questions de clarification de Claude aux utilisateurs, puis renvoyez leurs décisions au SDK.

9Lors du travail sur une tâche, Claude a parfois besoin de vérifier auprès des utilisateurs. Il peut avoir besoin d'une permission avant de supprimer des fichiers, ou avoir besoin de demander quelle base de données utiliser pour un nouveau projet. Votre application doit présenter ces demandes aux utilisateurs afin que Claude puisse continuer avec leurs entrées.

11Claude demande une entrée utilisateur dans deux situations : lorsqu'il a besoin d'une **permission pour utiliser un outil** (comme supprimer des fichiers ou exécuter des commandes), et lorsqu'il a des **questions de clarification** (via l'outil `AskUserQuestion`). Les deux déclenchent votre callback `canUseTool`, qui met en pause l'exécution jusqu'à ce que vous retourniez une réponse. C'est différent des tours de conversation normaux où Claude termine et attend votre prochain message.

13Pour les questions de clarification, Claude génère les questions et les options. Votre rôle est de les présenter aux utilisateurs et de retourner leurs sélections. Vous ne pouvez pas ajouter vos propres questions à ce flux ; si vous avez besoin de poser une question aux utilisateurs vous-même, faites-le séparément dans votre logique d'application.

15Le callback peut rester en attente indéfiniment. L'exécution reste en pause jusqu'à ce que votre callback retourne, et le SDK n'annule l'attente que lorsque la requête elle-même est annulée. Si un utilisateur pourrait prendre plus de temps pour répondre que votre processus ne peut raisonnablement rester en cours d'exécution, le SDK TypeScript supporte le [hook `defer` decision](/fr/hooks#defer-a-tool-call-for-later), qui permet au processus de quitter et de reprendre plus tard à partir de la session persistante ; cette option n'est pas disponible dans le SDK Python.

17Ce guide vous montre comment détecter chaque type de demande et répondre de manière appropriée.

19## Détecter quand Claude a besoin d'une entrée

21Passez un callback `canUseTool` dans vos options de requête. Le callback se déclenche chaque fois que Claude a besoin d'une entrée utilisateur, en recevant le nom de l'outil et l'entrée comme arguments :

23<CodeGroup>

24 ```python Python theme={null}

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

26 # Inviter l'utilisateur et retourner allow ou deny

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 // Inviter l'utilisateur et retourner allow ou deny

37 }

39 const options = { canUseTool: handleToolRequest };

40 ```

41</CodeGroup>

43Le callback se déclenche dans deux cas :

451. **L'outil a besoin d'approbation** : Claude veut utiliser un outil qui n'est pas auto-approuvé par les [règles de permission](/fr/agent-sdk/permissions) ou les modes. Vérifiez `tool_name` pour l'outil (par exemple, `"Bash"`, `"Write"`).

462. **Claude pose une question** : Claude appelle l'outil `AskUserQuestion`. Vérifiez si `tool_name == "AskUserQuestion"` pour le gérer différemment. Si vous spécifiez un tableau `tools`, incluez `AskUserQuestion` pour que cela fonctionne. Voir [Gérer les questions de clarification](#handle-clarifying-questions) pour plus de détails.

48<Note>

49 Pour autoriser ou refuser automatiquement les outils sans inviter les utilisateurs, utilisez plutôt les [hooks](/fr/agent-sdk/hooks). Les hooks s'exécutent avant `canUseTool` et peuvent autoriser, refuser ou modifier les demandes en fonction de votre propre logique. Vous pouvez également utiliser le [hook `PermissionRequest`](/fr/agent-sdk/hooks#available-hooks) pour envoyer des notifications externes (Slack, email, push) lorsque Claude attend une approbation.

50</Note>

52## Gérer les demandes d'approbation d'outil

54Une fois que vous avez passé un callback `canUseTool` dans vos options de requête, il se déclenche lorsque Claude veut utiliser un outil qui n'est pas auto-approuvé. Votre callback reçoit trois arguments :

56| Argument | Description |

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

58| `toolName` | Le nom de l'outil que Claude veut utiliser (par exemple, `"Bash"`, `"Write"`, `"Edit"`) |

59| `input` | Les paramètres que Claude passe à l'outil. Le contenu varie selon l'outil. |

60| `options` (TS) / `context` (Python) | Contexte supplémentaire incluant des `suggestions` optionnelles (entrées `PermissionUpdate` proposées pour éviter de re-inviter) et un signal d'annulation. En TypeScript, `signal` est un `AbortSignal` ; en Python, le champ signal est réservé pour une utilisation future. Voir [`ToolPermissionContext`](/fr/agent-sdk/python#toolpermissioncontext) pour Python. |

62L'objet `input` contient des paramètres spécifiques à l'outil. Exemples courants :

64| Outil | Champs d'entrée |

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` |

71Voir la référence du SDK pour les schémas d'entrée complets : [Python](/fr/agent-sdk/python#tool-input%2Foutput-types) | [TypeScript](/fr/agent-sdk/typescript#tool-input-types).

73Vous pouvez afficher ces informations à l'utilisateur afin qu'il puisse décider d'autoriser ou de rejeter l'action, puis retourner la réponse appropriée.

75L'exemple suivant demande à Claude de créer et de supprimer un fichier de test. Lorsque Claude tente chaque opération, le callback imprime la demande d'outil au terminal et invite à une approbation y/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 # Afficher la demande d'outil

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 # Obtenir l'approbation de l'utilisateur

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

104

105 # Retourner allow ou deny en fonction de la réponse de l'utilisateur

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

107 # Allow: l'outil s'exécute avec l'entrée originale (ou modifiée)

108 return PermissionResultAllow(updated_input=input_data)

109 else:

110 # Deny: l'outil ne s'exécute pas, Claude voit le message

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

112

113

114 # Contournement requis : un hook factice garde le flux ouvert pour 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 to prompt user for input in the 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 // Afficher la demande d'outil

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 // Obtenir l'approbation de l'utilisateur

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

177

178 // Retourner allow ou deny en fonction de la réponse de l'utilisateur

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

180 // Allow: l'outil s'exécute avec l'entrée originale (ou modifiée)

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

182 } else {

183 // Deny: l'outil ne s'exécute pas, Claude voit le message

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` nécessite le [mode streaming](/fr/agent-sdk/streaming-vs-single-mode) et un hook `PreToolUse` qui retourne `{"continue_": True}` pour garder le flux ouvert. Sans ce hook, le flux se ferme avant que le callback de permission puisse être invoqué.

196</Note>

197

198Cet exemple utilise un flux y/n où toute entrée autre que `y` est traitée comme un refus. En pratique, vous pourriez construire une interface utilisateur plus riche qui permet aux utilisateurs de modifier la demande, de fournir des commentaires, ou de rediriger Claude entièrement. Voir [Répondre aux demandes d'outil](#respond-to-tool-requests) pour tous les moyens de répondre.

199

200### Répondre aux demandes d'outil

201

202Votre callback retourne l'un de deux types de réponse :

203

204| Réponse | Python | TypeScript |

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

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

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

208

209Lors de l'autorisation, passez l'entrée de l'outil (originale ou modifiée). Lors du refus, fournissez un message expliquant pourquoi. Claude voit ce message et peut ajuster son approche.

210

211<CodeGroup>

212 ```python Python theme={null}

213 from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

214

215 # Autoriser l'outil à s'exécuter

216 return PermissionResultAllow(updated_input=input_data)

217

218 # Bloquer l'outil

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

220 ```

221

222 ```typescript TypeScript theme={null}

223 // Autoriser l'outil à s'exécuter

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

225

226 // Bloquer l'outil

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

228 ```

229</CodeGroup>

230

231Au-delà de l'autorisation ou du refus, vous pouvez modifier l'entrée de l'outil ou fournir un contexte qui aide Claude à ajuster son approche :

232

233* **Approuver** : laisser l'outil s'exécuter comme Claude l'a demandé

234* **Approuver avec des modifications** : modifier l'entrée avant l'exécution (par exemple, nettoyer les chemins, ajouter des contraintes)

235* **Rejeter** : bloquer l'outil et dire à Claude pourquoi

236* **Suggérer une alternative** : bloquer mais guider Claude vers ce que l'utilisateur veut à la place

237* **Rediriger entièrement** : utiliser [streaming input](/fr/agent-sdk/streaming-vs-single-mode) pour envoyer à Claude une instruction complètement nouvelle

238

239<Tabs>

240 <Tab title="Approuver">

241 L'utilisateur approuve l'action telle quelle. Passez l'`input` de votre callback inchangée et l'outil s'exécute exactement comme Claude l'a demandé.

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="Approuver avec des modifications">

269 L'utilisateur approuve mais veut d'abord modifier la demande. Vous pouvez modifier l'entrée avant l'exécution de l'outil. Claude voit le résultat mais n'est pas informé que vous avez changé quelque chose. Utile pour nettoyer les paramètres, ajouter des contraintes, ou limiter l'accès.

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 # L'utilisateur a approuvé, mais limiter toutes les commandes au 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 // L'utilisateur a approuvé, mais limiter toutes les commandes au 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="Rejeter">

301 L'utilisateur ne veut pas que cette action se produise. Bloquez l'outil et fournissez un message expliquant pourquoi. Claude voit ce message et peut essayer une approche différente.

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="Suggérer une alternative">

330 L'utilisateur ne veut pas cette action spécifique, mais a une idée différente. Bloquez l'outil et incluez des conseils dans votre message. Claude lira ceci et décidera comment procéder en fonction de vos commentaires.

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 # L'utilisateur ne veut pas supprimer, suggérer d'archiver à la place

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 // L'utilisateur ne veut pas supprimer, suggérer d'archiver à la place

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="Rediriger entièrement">

360 Pour un changement de direction complet (pas seulement une nudge), utilisez [streaming input](/fr/agent-sdk/streaming-vs-single-mode) pour envoyer à Claude une nouvelle instruction directement. Cela contourne la demande d'outil actuelle et donne à Claude des instructions entièrement nouvelles à suivre.

361 </Tab>

362</Tabs>

363

364## Gérer les questions de clarification

365

366Lorsque Claude a besoin de plus de direction sur une tâche avec plusieurs approches valides, il appelle l'outil `AskUserQuestion`. Cela déclenche votre callback `canUseTool` avec `toolName` défini sur `AskUserQuestion`. L'entrée contient les questions de Claude sous forme d'options à choix multiples, que vous affichez à l'utilisateur et retournez ses sélections.

367

368<Tip>

369 Les questions de clarification sont particulièrement courantes en [mode `plan`](/fr/agent-sdk/permissions#plan-mode-plan), où Claude explore la base de code et pose des questions avant de proposer un plan. Cela rend le mode plan idéal pour les flux de travail interactifs où vous voulez que Claude rassemble les exigences avant de faire des modifications.

370</Tip>

371

372Les étapes suivantes montrent comment gérer les questions de clarification :

373

374<Steps>

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

376 Passez un callback `canUseTool` dans vos options de requête. Par défaut, `AskUserQuestion` est disponible. Si vous spécifiez un tableau `tools` pour restreindre les capacités de Claude (par exemple, un agent en lecture seule avec seulement `Read`, `Glob`, et `Grep`), incluez `AskUserQuestion` dans ce tableau. Sinon, Claude ne pourra pas poser de questions de clarification :

377

378 <CodeGroup>

379 ```python Python theme={null}

380 async for message in query(

381 prompt="Analyze this codebase",

382 options=ClaudeAgentOptions(

383 # Inclure AskUserQuestion dans votre liste d'outils

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 // Inclure AskUserQuestion dans votre liste d'outils

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

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

398 // Gérer les questions de clarification ici

399 }

400 }

401 })) {

402 console.log(message);

403 }

404 ```

405 </CodeGroup>

406 </Step>

407

408 <Step title="Détecter AskUserQuestion">

409 Dans votre callback, vérifiez si `toolName` est égal à `AskUserQuestion` pour le gérer différemment des autres outils :

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 # Votre implémentation pour collecter les réponses de l'utilisateur

416 return await handle_clarifying_questions(input_data)

417 # Gérer les autres outils normalement

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 // Votre implémentation pour collecter les réponses de l'utilisateur

425 return handleClarifyingQuestions(input);

426 }

427 // Gérer les autres outils normalement

428 return promptForApproval(toolName, input);

429 };

430 ```

431 </CodeGroup>

432 </Step>

433

434 <Step title="Analyser l'entrée de la question">

435 L'entrée contient les questions de Claude dans un tableau `questions`. Chaque question a une `question` (le texte à afficher), des `options` (les choix), et `multiSelect` (si plusieurs sélections sont autorisées) :

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 Voir [Format de question](#question-format) pour les descriptions complètes des champs.

463 </Step>

464

465 <Step title="Collecter les réponses de l'utilisateur">

466 Présentez les questions à l'utilisateur et collectez ses sélections. La façon dont vous le faites dépend de votre application : une invite de terminal, un formulaire web, un dialogue mobile, etc.

467 </Step>

468

469 <Step title="Retourner les réponses à Claude">

470 Construisez l'objet `answers` comme un enregistrement où chaque clé est le texte de `question` et chaque valeur est le `label` de l'option sélectionnée :

471

472 | De l'objet question | Utiliser comme |

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

474 | Champ `question` (par exemple, `"How should I format the output?"`) | Clé |

475 | Champ `label` de l'option sélectionnée (par exemple, `"Summary"`) | Valeur |

476

477 Pour les questions multi-sélection, passez un tableau de labels ou joignez-les avec `", "`. Si vous [supportez l'entrée de texte libre](#support-free-text-input), utilisez le texte personnalisé de l'utilisateur comme valeur.

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### Format de question

509

510L'entrée contient les questions générées par Claude dans un tableau `questions`. Chaque question a ces champs :

511

512| Champ | Description |

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

514| `question` | Le texte complet de la question à afficher |

515| `header` | Étiquette courte pour la question (max 12 caractères) |

516| `options` | Tableau de 2-4 choix, chacun avec `label` et `description`. TypeScript : optionnellement `preview` (voir [ci-dessous](#option-previews-type-script)) |

517| `multiSelect` | Si `true`, les utilisateurs peuvent sélectionner plusieurs options |

518

519La structure que votre callback reçoit :

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#### Aperçus d'options (TypeScript)

538

539`toolConfig.askUserQuestion.previewFormat` ajoute un champ `preview` à chaque option afin que votre application puisse afficher une maquette visuelle à côté du label. Sans ce paramètre, Claude ne génère pas d'aperçus et le champ est absent.

540

541| `previewFormat` | `preview` contient |

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

543| non défini (par défaut) | Le champ est absent. Claude ne génère pas d'aperçus. |

544| `"markdown"` | Art ASCII et blocs de code clôturés |

545| `"html"` | Un fragment `<div>` stylisé (le SDK rejette `<script>`, `<style>`, et `<!DOCTYPE>` avant que votre callback ne s'exécute) |

546

547Le format s'applique à toutes les questions de la session. Claude inclut `preview` sur les options où une comparaison visuelle aide (choix de mise en page, schémas de couleurs) et l'omet où ce ne serait pas le cas (confirmations oui/non, choix texte uniquement). Vérifiez `undefined` avant de rendre.

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 is an HTML string or undefined

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

561 }

562 }

563})) {

564 // ...

565}

566```

567

568Une option avec un aperçu 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### Format de réponse

579

580Retournez un objet `answers` mappant le champ `question` de chaque question au `label` de l'option sélectionnée :

581

582| Champ | Description |

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

584| `questions` | Passez le tableau de questions original (requis pour le traitement de l'outil) |

585| `answers` | Objet où les clés sont le texte de la question et les valeurs sont les labels sélectionnés |

586

587Pour les questions multi-sélection, passez un tableau de labels ou joignez-les avec `", "`. Pour l'entrée de texte libre, utilisez le texte personnalisé de l'utilisateur directement.

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#### Supporter l'entrée de texte libre

602

603Les options prédéfinies de Claude ne couvriront pas toujours ce que les utilisateurs veulent. Pour permettre aux utilisateurs de taper leur propre réponse :

604

605* Affichez un choix supplémentaire « Autre » après les options de Claude qui accepte l'entrée de texte

606* Utilisez le texte personnalisé de l'utilisateur comme valeur de réponse (pas le mot « Autre »)

607

608Voir l'[exemple complet](#complete-example) ci-dessous pour une implémentation complète.

609

610### Exemple complet

611

612Claude pose des questions de clarification lorsqu'il a besoin d'une entrée utilisateur pour continuer. Par exemple, lorsqu'on lui demande d'aider à décider d'une pile technologique pour une application mobile, Claude pourrait poser des questions sur cross-platform vs native, les préférences de backend, ou les plates-formes cibles. Ces questions aident Claude à prendre des décisions qui correspondent aux préférences de l'utilisateur plutôt que de deviner.

613

614Cet exemple gère ces questions dans une application de terminal. Voici ce qui se passe à chaque étape :

615

6161. **Router la demande** : Le callback `canUseTool` vérifie si le nom de l'outil est `"AskUserQuestion"` et route vers un gestionnaire dédié

6172. **Afficher les questions** : Le gestionnaire boucle à travers le tableau `questions` et imprime chaque question avec des options numérotées

6183. **Collecter l'entrée** : L'utilisateur peut entrer un numéro pour sélectionner une option, ou taper du texte libre directement (par exemple, « jquery », « je ne sais pas »)

6194. **Mapper les réponses** : Le code vérifie si l'entrée est numérique (utilise le label de l'option) ou du texte libre (utilise le texte directement)

6205. **Retourner à Claude** : La réponse inclut à la fois le tableau `questions` original et le mapping `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 """Analyser l'entrée utilisateur comme numéro(s) d'option ou texte 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 """Afficher les questions de Claude et collecter les réponses de l'utilisateur."""

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 # Router AskUserQuestion vers notre gestionnaire de questions

670 if tool_name == "AskUserQuestion":

671 return await handle_ask_user_question(input_data)

672 # Auto-approuver les autres outils pour cet exemple

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 # Contournement requis : un hook factice garde le flux ouvert pour 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 to prompt user for input in the 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 // Parse user input as option number(s) or free text

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 // Display Claude's questions and collect user answers

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 // Return the answers to Claude (must include original questions)

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 // Router AskUserQuestion vers notre gestionnaire de questions

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

762 return handleAskUserQuestion(input);

763 }

764 // Auto-approuver les autres outils pour cet exemple

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## Limitations

778

779* **Subagents** : `AskUserQuestion` n'est actuellement pas disponible dans les subagents générés via l'outil Agent

780* **Limites de questions** : chaque appel `AskUserQuestion` supporte 1-4 questions avec 2-4 options chacune

781

782## Autres façons d'obtenir une entrée utilisateur

783

784Le callback `canUseTool` et l'outil `AskUserQuestion` couvrent la plupart des scénarios d'approbation et de clarification, mais le SDK offre d'autres façons d'obtenir une entrée des utilisateurs :

785

786### Streaming input

787

788Utilisez [streaming input](/fr/agent-sdk/streaming-vs-single-mode) lorsque vous avez besoin de :

789

790* **Interrompre l'agent en cours de tâche** : envoyer un signal d'annulation ou changer de direction pendant que Claude travaille

791* **Fournir un contexte supplémentaire** : ajouter des informations dont Claude a besoin sans attendre qu'il les demande

792* **Construire des interfaces de chat** : permettre aux utilisateurs d'envoyer des messages de suivi pendant les opérations longues

793

794Streaming input est idéal pour les interfaces conversationnelles où les utilisateurs interagissent avec l'agent tout au long de l'exécution, pas seulement aux points d'approbation.

795

796### Outils personnalisés

797

798Utilisez [outils personnalisés](/fr/agent-sdk/custom-tools) lorsque vous avez besoin de :

799

800* **Collecter une entrée structurée** : construire des formulaires, des assistants, ou des flux de travail multi-étapes qui vont au-delà du format à choix multiples de `AskUserQuestion`

801* **Intégrer des systèmes d'approbation externes** : se connecter à des plates-formes de ticketing, de flux de travail, ou d'approbation existantes

802* **Implémenter des interactions spécifiques au domaine** : créer des outils adaptés aux besoins de votre application, comme des interfaces d'examen de code ou des listes de contrôle de déploiement

803

804Les outils personnalisés vous donnent un contrôle total sur l'interaction, mais nécessitent plus de travail d'implémentation que d'utiliser le callback `canUseTool` intégré.

805

806## Ressources connexes

807

808* [Configurer les permissions](/fr/agent-sdk/permissions) : configurer les modes et règles de permission

809* [Contrôler l'exécution avec les hooks](/fr/agent-sdk/hooks) : exécuter du code personnalisé à des points clés du cycle de vie de l'agent

810* [Référence du SDK TypeScript](/fr/agent-sdk/typescript#canusetool) : documentation complète de l'API canUseTool

auto-mode-config.md +16 −11

Details

39 39

40Le classificateur ne lit pas `autoMode` à partir des paramètres de projet partagés dans `.claude/settings.json`, donc un dépôt enregistré ne peut pas injecter ses propres règles d'autorisation.40Le classificateur ne lit pas `autoMode` à partir des paramètres de projet partagés dans `.claude/settings.json`, donc un dépôt enregistré ne peut pas injecter ses propres règles d'autorisation.

41 41

42Les entrées de chaque portée sont combinées. Un développeur peut étendre `environment`, `allow` et `soft_deny` avec des entrées personnelles mais ne peut pas supprimer les entrées que les paramètres gérés fournissent. Parce que les règles d'autorisation agissent comme des exceptions aux règles de blocage à l'intérieur du classificateur, une entrée `allow` ajoutée par un développeur peut remplacer une entrée `soft_deny` d'organisation : la combinaison est additive, pas une limite de politique stricte.42Les entrées de chaque portée sont combinées. Un développeur peut étendre `environment`, `allow`, `soft_deny` et `hard_deny` avec des entrées personnelles mais ne peut pas supprimer les entrées que les paramètres gérés fournissent. Parce que les règles d'autorisation agissent comme des exceptions aux règles de blocage à l'intérieur du classificateur, une entrée `allow` ajoutée par un développeur peut remplacer une entrée `soft_deny` d'organisation : la combinaison est additive, pas une limite de politique stricte.

43 43

44<Note>44<Note>

45 Le classificateur est une deuxième porte qui s'exécute après le [système de permissions](/fr/permissions). Pour les actions qui ne doivent jamais s'exécuter indépendamment de l'intention de l'utilisateur ou de la configuration du classificateur, utilisez `permissions.deny` dans les paramètres gérés, qui bloque l'action avant que le classificateur ne soit consulté et ne peut pas être remplacée.45 Le classificateur est une deuxième porte qui s'exécute après le [système de permissions](/fr/permissions). Pour les actions qui ne doivent jamais s'exécuter indépendamment de l'intention de l'utilisateur ou de la configuration du classificateur, utilisez `permissions.deny` dans les paramètres gérés, qui bloque l'action avant que le classificateur ne soit consulté et ne peut pas être remplacée.

99 99

100## Remplacer les règles de blocage et d'autorisation100## Remplacer les règles de blocage et d'autorisation

101 101

102Deux champs supplémentaires vous permettent de remplacer les listes de règles intégrées du classificateur : `autoMode.soft_deny` contrôle ce qui est bloqué, et `autoMode.allow` contrôle quelles exceptions s'appliquent. Chacun est un tableau de descriptions en prose, lu comme des règles en langage naturel. Il n'y a pas de champ `autoMode.deny` ; pour bloquer dur une action indépendamment de l'intention, utilisez [`permissions.deny`](/fr/permissions), qui s'exécute avant le classificateur.102Trois champs supplémentaires vous permettent de remplacer les listes de règles intégrées du classificateur : `autoMode.hard_deny` pour les limites de sécurité inconditionnelles, `autoMode.soft_deny` pour les actions destructrices que l'intention de l'utilisateur peut lever, et `autoMode.allow` pour les exceptions. Chacun est un tableau de descriptions en prose, lu comme des règles en langage naturel. Pour les blocages durs basés sur des motifs d'outils qui s'exécutent avant le classificateur, utilisez [`permissions.deny`](/fr/permissions).

103 103

104À l'intérieur du classificateur, la précédence fonctionne en trois niveaux :104À l'intérieur du classificateur, la précédence fonctionne en quatre niveaux :

105 105

106* Les règles `soft_deny` bloquent d'abord106* Les règles `hard_deny` bloquent inconditionnellement. L'intention de l'utilisateur et les exceptions `allow` ne s'appliquent pas.

107* Les règles `allow` remplacent ensuite les blocages correspondants comme exceptions107* Les règles `soft_deny` bloquent ensuite. L'intention de l'utilisateur et les exceptions `allow` peuvent remplacer celles-ci.

108* L'intention explicite de l'utilisateur remplace les deux : si le message de l'utilisateur décrit directement et spécifiquement l'action exacte que Claude est sur le point de prendre, le classificateur l'autorise même quand une règle `soft_deny` correspond108* Les règles `allow` remplacent ensuite les règles `soft_deny` correspondantes comme exceptions.

109* L'intention explicite de l'utilisateur remplace les blocages souples restants : si le message de l'utilisateur décrit directement et spécifiquement l'action exacte que Claude est sur le point de prendre, le classificateur l'autorise même quand une règle `soft_deny` correspond.

109 110

110Les demandes générales ne comptent pas comme une intention explicite. Demander à Claude de « nettoyer le dépôt » n'autorise pas la poussée forcée, mais demander à Claude de « forcer la poussée de cette branche » le fait.111Les demandes générales ne comptent pas comme une intention explicite. Demander à Claude de « nettoyer le dépôt » n'autorise pas la poussée forcée, mais demander à Claude de « forcer la poussée de cette branche » le fait.

111 112

112Pour assouplir, ajoutez à `allow` quand le classificateur signale à plusieurs reprises un motif courant que les exceptions par défaut ne couvrent pas. Pour renforcer, ajoutez à `soft_deny` pour les risques spécifiques à votre environnement que les valeurs par défaut manquent. Pour conserver les règles intégrées tout en ajoutant les vôtres, incluez la chaîne littérale `"$defaults"` dans le tableau. Les règles par défaut sont insérées à cette position, donc vos règles personnalisées peuvent aller avant ou après elles, et vous continuez à hériter des mises à jour à mesure que la liste intégrée change entre les versions.113Pour assouplir, ajoutez à `allow` quand le classificateur signale à plusieurs reprises un motif courant que les exceptions par défaut ne couvrent pas. Pour renforcer, ajoutez à `soft_deny` pour les risques destructeurs spécifiques à votre environnement que les valeurs par défaut manquent, ou à `hard_deny` pour les limites de sécurité qui ne doivent jamais être franchies. Pour conserver les règles intégrées tout en ajoutant les vôtres, incluez la chaîne littérale `"$defaults"` dans le tableau. Les règles par défaut sont insérées à cette position, donc vos règles personnalisées peuvent aller avant ou après elles, et vous continuez à hériter des mises à jour à mesure que la liste intégrée change entre les versions.

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 La définition de l'un de `environment`, `allow` ou `soft_deny` sans `"$defaults"` remplace la liste par défaut entière pour cette section. Si vous définissez `soft_deny` avec une seule entrée et omettez `"$defaults"`, chaque règle de blocage intégrée est rejetée : poussée forcée, exfiltration de données, `curl | bash`, déploiements en production et toutes les autres règles de blocage par défaut deviennent autorisées. Omettez `"$defaults"` uniquement quand vous avez l'intention de prendre la responsabilité complète de la liste. Dans ce cas, exécutez `claude auto-mode defaults` pour imprimer les règles intégrées, copiez-les dans votre fichier de paramètres, puis examinez chaque règle par rapport à votre propre pipeline et tolérance au risque.141 La définition de l'un de `environment`, `allow`, `soft_deny` ou `hard_deny` sans `"$defaults"` remplace la liste par défaut entière pour cette section. Un tableau `soft_deny` sans `"$defaults"` rejette chaque règle de blocage intégrée, y compris la poussée forcée, `curl | bash` et les déploiements en production. Un tableau `hard_deny` sans `"$defaults"` rejette les règles intégrées d'exfiltration de données et de contournement des vérifications de sécurité.

137</Danger>142</Danger>

138 143

139Chaque section est évaluée indépendamment, donc la définition de `environment` seule laisse les listes `allow` et `soft_deny` par défaut intactes.144Chaque section est évaluée indépendamment, donc la définition de `environment` seule laisse les listes `allow`, `soft_deny` et `hard_deny` par défaut intactes. Omettez `"$defaults"` uniquement quand vous avez l'intention de prendre la responsabilité complète de la liste. Pour ce faire en toute sécurité, exécutez `claude auto-mode defaults` pour imprimer les règles intégrées, copiez-les dans votre fichier de paramètres, puis examinez chaque règle par rapport à votre propre pipeline et tolérance au risque.

140 145

141## Inspecter les valeurs par défaut et votre configuration effective146## Inspecter les valeurs par défaut et votre configuration effective

142 147

143Trois sous-commandes CLI vous aident à inspecter et valider votre configuration.148Trois sous-commandes CLI vous aident à inspecter et valider votre configuration.

144 149

145Imprimez les règles `environment`, `allow` et `soft_deny` intégrées en JSON :150Imprimez les règles `environment`, `allow`, `soft_deny` et `hard_deny` intégrées en 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

157Obtenez des commentaires IA sur vos règles `allow` et `soft_deny` personnalisées :162Obtenez des commentaires IA sur vos règles `allow`, `soft_deny` et `hard_deny` personnalisées :

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>` | Poser une [question rapide](/fr/interactive-mode#side-questions-with-%2Fbtw) sans l'ajouter à la conversation |46| `/btw <question>` | Poser une [question rapide](/fr/interactive-mode#side-questions-with-%2Fbtw) sans l'ajouter à la conversation |

48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/fr/skills#bundled-skills).** Charger le matériel de référence de l'API Claude pour le langage de votre projet (Python, TypeScript, Java, Go, Ruby, C#, PHP, ou cURL) et la référence des Agents gérés. Couvre l'utilisation d'outils, le streaming, les lots, les sorties structurées et les pièges courants. S'active également automatiquement lorsque votre code importe `anthropic` ou `@anthropic-ai/sdk`. Exécutez `/claude-api migrate` pour mettre à niveau le code existant de l'API Claude vers un modèle plus récent : Claude vous demande quels fichiers analyser et quel modèle cibler, puis met à jour les ID de modèle, la configuration de la réflexion et d'autres paramètres qui ont changé entre les versions. Exécutez `/claude-api managed-agents-onboard` pour une procédure pas à pas interactive qui crée un nouvel Agent géré à partir de zéro |48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/fr/skills#bundled-skills).** Charger le matériel de référence de l'API Claude pour le langage de votre projet (Python, TypeScript, Java, Go, Ruby, C#, PHP, ou cURL) et la référence des Agents gérés. Couvre l'utilisation d'outils, le streaming, les lots, les sorties structurées et les pièges courants. S'active également automatiquement lorsque votre code importe `anthropic` ou `@anthropic-ai/sdk`. Exécutez `/claude-api migrate` pour mettre à niveau le code existant de l'API Claude vers un modèle plus récent : Claude vous demande quels fichiers analyser et quel modèle cibler, puis met à jour les ID de modèle, la configuration de la réflexion et d'autres paramètres qui ont changé entre les versions. Exécutez `/claude-api managed-agents-onboard` pour une procédure pas à pas interactive qui crée un nouvel Agent géré à partir de zéro |

49| `/clear` | Démarrer une nouvelle conversation avec un contexte vide. La conversation précédente reste disponible dans `/resume`. Pour libérer du contexte tout en continuant la même conversation, utilisez `/compact` à la place. Alias : `/reset`, `/new` |49| `/clear [name]` | Démarrer une nouvelle conversation avec un contexte vide. La conversation précédente reste disponible dans `/resume`. Passez un nom pour étiqueter la conversation précédente dans le sélecteur `/resume`. Pour libérer du contexte tout en continuant la même conversation, utilisez `/compact` à la place. Alias : `/reset`, `/new` |

50| `/color [color\|default]` | Définir la couleur de la barre d'invite pour la session actuelle. Couleurs disponibles : `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Utilisez `default` pour réinitialiser, ou exécutez sans argument pour choisir une couleur aléatoire. Lorsque [Remote Control](/fr/remote-control) est connecté, la couleur se synchronise avec claude.ai/code |50| `/color [color\|default]` | Définir la couleur de la barre d'invite pour la session actuelle. Couleurs disponibles : `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Utilisez `default` pour réinitialiser, ou exécutez sans argument pour choisir une couleur aléatoire. Lorsque [Remote Control](/fr/remote-control) est connecté, la couleur se synchronise avec claude.ai/code |

51| `/compact [instructions]` | Libérer du contexte en résumant la conversation jusqu'à présent. Passez optionnellement des instructions de focus pour le résumé. Consultez [comment la compaction gère les règles, les skills et les fichiers de mémoire](/fr/context-window#what-survives-compaction) |51| `/compact [instructions]` | Libérer du contexte en résumant la conversation jusqu'à présent. Passez optionnellement des instructions de focus pour le résumé. Consultez [comment la compaction gère les règles, les skills et les fichiers de mémoire](/fr/context-window#what-survives-compaction) |

52| `/config` | Ouvrir l'interface des [Paramètres](/fr/settings) pour ajuster le thème, le modèle, le [style de sortie](/fr/output-styles) et d'autres préférences. Alias : `/settings` |52| `/config` | Ouvrir l'interface des [Paramètres](/fr/settings) pour ajuster le thème, le modèle, le [style de sortie](/fr/output-styles) et d'autres préférences. Alias : `/settings` |

53| `/context` | Visualiser l'utilisation actuelle du contexte sous forme de grille colorée. Affiche les suggestions d'optimisation pour les outils gourmands en contexte, le surpoids de la mémoire et les avertissements de capacité |53| `/context [all]` | Visualiser l'utilisation actuelle du contexte sous forme de grille colorée. Affiche les suggestions d'optimisation pour les outils gourmands en contexte, le surpoids de la mémoire et les avertissements de capacité. En [mode plein écran](/fr/fullscreen), la ventilation par élément est réduite pour garder la grille visible. Passez `all` pour l'étendre |

54| `/copy [N]` | Copier la dernière réponse de l'assistant dans le presse-papiers. Passez un nombre `N` pour copier la Nième réponse la plus récente : `/copy 2` copie l'avant-dernière. Lorsque des blocs de code sont présents, affiche un sélecteur interactif pour sélectionner des blocs individuels ou la réponse complète. Appuyez sur `w` dans le sélecteur pour écrire la sélection dans un fichier au lieu du presse-papiers, ce qui est utile via SSH |54| `/copy [N]` | Copier la dernière réponse de l'assistant dans le presse-papiers. Passez un nombre `N` pour copier la Nième réponse la plus récente : `/copy 2` copie l'avant-dernière. Lorsque des blocs de code sont présents, affiche un sélecteur interactif pour sélectionner des blocs individuels ou la réponse complète. Appuyez sur `w` dans le sélecteur pour écrire la sélection dans un fichier au lieu du presse-papiers, ce qui est utile via SSH |

56| `/debug [description]` | **[Skill](/fr/skills#bundled-skills).** Activer la journalisation de débogage pour la session actuelle et dépanner les problèmes en lisant le journal de débogage de la session. La journalisation de débogage est désactivée par défaut sauf si vous avez démarré avec `claude --debug`, donc exécuter `/debug` en milieu de session commence à capturer les journaux à partir de ce moment. Décrivez optionnellement le problème pour concentrer l'analyse |56| `/debug [description]` | **[Skill](/fr/skills#bundled-skills).** Activer la journalisation de débogage pour la session actuelle et dépanner les problèmes en lisant le journal de débogage de la session. La journalisation de débogage est désactivée par défaut sauf si vous avez démarré avec `claude --debug`, donc exécuter `/debug` en milieu de session commence à capturer les journaux à partir de ce moment. Décrivez optionnellement le problème pour concentrer l'analyse |

89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Supprimé dans v2.1.91. Demandez à Claude directement de consulter les commentaires de demande de tirage à la place. Sur les versions antérieures, récupère et affiche les commentaires d'une demande de tirage GitHub ; détecte automatiquement la PR pour la branche actuelle, ou passez une URL ou un numéro de PR. Nécessite le CLI `gh` |89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Supprimé dans v2.1.91. Demandez à Claude directement de consulter les commentaires de demande de tirage à la place. Sur les versions antérieures, récupère et affiche les commentaires d'une demande de tirage GitHub ; détecte automatiquement la PR pour la branche actuelle, ou passez une URL ou un numéro de PR. Nécessite le CLI `gh` |

90| `/privacy-settings` | Afficher et mettre à jour vos paramètres de confidentialité. Disponible uniquement pour les abonnés aux plans Pro et Max |90| `/privacy-settings` | Afficher et mettre à jour vos paramètres de confidentialité. Disponible uniquement pour les abonnés aux plans Pro et Max |

91| `/radio` | Ouvrir Claude FM lo-fi radio dans votre navigateur. Affiche l'URL du flux lorsqu'aucun navigateur n'est disponible. Non disponible sur Bedrock, Vertex, ou Foundry |

91| `/recap` | Générer un résumé d'une ligne de la session actuelle à la demande. Consultez [Récapitulatif de session](/fr/interactive-mode#session-recap) pour le récapitulatif automatique qui apparaît après votre absence |92| `/recap` | Générer un résumé d'une ligne de la session actuelle à la demande. Consultez [Récapitulatif de session](/fr/interactive-mode#session-recap) pour le récapitulatif automatique qui apparaît après votre absence |

92| `/release-notes` | Afficher le journal des modifications dans un sélecteur de version interactif. Sélectionnez une version spécifique pour voir ses notes de version, ou choisissez d'afficher toutes les versions |93| `/release-notes` | Afficher le journal des modifications dans un sélecteur de version interactif. Sélectionnez une version spécifique pour voir ses notes de version, ou choisissez d'afficher toutes les versions |

93| `/reload-plugins` | Recharger tous les [plugins](/fr/plugins) actifs pour appliquer les modifications en attente sans redémarrer. Signale les comptages pour chaque composant rechargé et signale les erreurs de chargement |94| `/reload-plugins` | Recharger tous les [plugins](/fr/plugins) actifs pour appliquer les modifications en attente sans redémarrer. Signale les comptages pour chaque composant rechargé et signale les erreurs de chargement |

env-vars.md +2 −0

Details

117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Nombre maximal d'outils en lecture seule et de subagents qui peuvent s'exécuter en parallèle (par défaut : 10). Les valeurs plus élevées augmentent le parallélisme mais consomment plus de ressources |117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Nombre maximal d'outils en lecture seule et de subagents qui peuvent s'exécuter en parallèle (par défaut : 10). Les valeurs plus élevées augmentent le parallélisme mais consomment plus de ressources |

118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Définissez sur `1` pour générer les serveurs MCP stdio avec uniquement un environnement de base sûr plus l'`env` configuré du serveur, au lieu d'hériter de votre environnement shell |118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Définissez sur `1` pour générer les serveurs MCP stdio avec uniquement un environnement de base sûr plus l'`env` configuré du serveur, au lieu d'hériter de votre environnement shell |

119| `CLAUDE_CODE_NATIVE_CURSOR` | Définissez sur `1` pour afficher le curseur propre du terminal au curseur d'entrée au lieu d'un bloc dessiné. Le curseur respecte les paramètres de clignotement, de forme et de focus du terminal |

119| `CLAUDE_CODE_NEW_INIT` | Définissez sur `1` pour faire exécuter `/init` un flux de configuration interactif. Le flux demande quels fichiers générer, y compris CLAUDE.md, skills et hooks, avant d'explorer la base de code et de les écrire. Sans cette variable, `/init` génère un CLAUDE.md automatiquement sans demander. |120| `CLAUDE_CODE_NEW_INIT` | Définissez sur `1` pour faire exécuter `/init` un flux de configuration interactif. Le flux demande quels fichiers générer, y compris CLAUDE.md, skills et hooks, avant d'explorer la base de code et de les écrire. Sans cette variable, `/init` génère un CLAUDE.md automatiquement sans demander. |

120| `CLAUDE_CODE_NO_FLICKER` | Définissez sur `1` pour activer le [rendu en plein écran](/fr/fullscreen), un aperçu de recherche qui réduit le scintillement et maintient la mémoire plate dans les longues conversations. Équivalent au paramètre [`tui`](/fr/settings#available-settings) ; vous pouvez également basculer avec `/tui fullscreen` |121| `CLAUDE_CODE_NO_FLICKER` | Définissez sur `1` pour activer le [rendu en plein écran](/fr/fullscreen), un aperçu de recherche qui réduit le scintillement et maintient la mémoire plate dans les longues conversations. Équivalent au paramètre [`tui`](/fr/settings#available-settings) ; vous pouvez également basculer avec `/tui fullscreen` |

121| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | Jeton d'actualisation OAuth pour l'authentification Claude.ai. Lorsqu'il est défini, `claude auth login` échange ce jeton directement au lieu d'ouvrir un navigateur. Nécessite `CLAUDE_CODE_OAUTH_SCOPES`. Utile pour provisionner l'authentification dans les environnements automatisés |122| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | Jeton d'actualisation OAuth pour l'authentification Claude.ai. Lorsqu'il est défini, `claude auth login` échange ce jeton directement au lieu d'ouvrir un navigateur. Nécessite `CLAUDE_CODE_OAUTH_SCOPES`. Utile pour provisionner l'authentification dans les environnements automatisés |

191| `DISABLE_TELEMETRY` | Définissez sur `1` pour refuser la télémétrie. Les événements de télémétrie n'incluent pas les données utilisateur comme le code, les chemins de fichiers ou les commandes bash |192| `DISABLE_TELEMETRY` | Définissez sur `1` pour refuser la télémétrie. Les événements de télémétrie n'incluent pas les données utilisateur comme le code, les chemins de fichiers ou les commandes bash |

192| `DISABLE_UPDATES` | Définissez sur `1` pour bloquer toutes les mises à jour, y compris la commande manuelle `claude update` et `claude install`. Plus strict que `DISABLE_AUTOUPDATER`. À utiliser lors de la distribution de Claude Code via vos propres canaux et les utilisateurs ne doivent pas se mettre à jour automatiquement |193| `DISABLE_UPDATES` | Définissez sur `1` pour bloquer toutes les mises à jour, y compris la commande manuelle `claude update` et `claude install`. Plus strict que `DISABLE_AUTOUPDATER`. À utiliser lors de la distribution de Claude Code via vos propres canaux et les utilisateurs ne doivent pas se mettre à jour automatiquement |

195| `DO_NOT_TRACK` | Définissez sur `1` pour refuser la télémétrie. Équivalent à la définition de `DISABLE_TELEMETRY`. Honoré en tant que [convention standard inter-outils](https://consoledonottrack.com/) |

194| `ENABLE_CLAUDEAI_MCP_SERVERS` | Définissez sur `false` pour désactiver les [serveurs MCP claude.ai](/fr/mcp#use-mcp-servers-from-claude-ai) dans Claude Code. Activé par défaut pour les utilisateurs connectés |196| `ENABLE_CLAUDEAI_MCP_SERVERS` | Définissez sur `false` pour désactiver les [serveurs MCP claude.ai](/fr/mcp#use-mcp-servers-from-claude-ai) dans Claude Code. Activé par défaut pour les utilisateurs connectés |

195| `ENABLE_PROMPT_CACHING_1H` | Définissez sur `1` pour demander une TTL de cache d'invite d'une heure au lieu des 5 minutes par défaut. Destiné aux utilisateurs de clé API, [Bedrock](/fr/amazon-bedrock), [Vertex](/fr/google-vertex-ai) et [Foundry](/fr/microsoft-foundry). Les utilisateurs d'abonnement reçoivent automatiquement une TTL d'une heure. Les écritures de cache d'une heure sont facturées à un taux plus élevé |197| `ENABLE_PROMPT_CACHING_1H` | Définissez sur `1` pour demander une TTL de cache d'invite d'une heure au lieu des 5 minutes par défaut. Destiné aux utilisateurs de clé API, [Bedrock](/fr/amazon-bedrock), [Vertex](/fr/google-vertex-ai) et [Foundry](/fr/microsoft-foundry). Les utilisateurs d'abonnement reçoivent automatiquement une TTL d'une heure. Les écritures de cache d'une heure sont facturées à un taux plus élevé |

errors.md +16 −0

Details

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

252* Exécutez `/status` après pour confirmer que l'identifiant actif est votre abonnement253* Exécutez `/status` après pour confirmer que l'identifiant actif est votre abonnement

253* Si aucune variable d'environnement n'est définie et que l'erreur persiste, l'organisation désactivée est celle liée à votre `/login`. Contactez le support ou connectez-vous avec un compte différent.254* Si aucune variable d'environnement n'est définie et que l'erreur persiste, l'organisation désactivée est celle liée à votre `/login`. Contactez le support ou connectez-vous avec un compte différent.

254 255

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

257

258Votre administrateur d'équipe ou d'entreprise a désactivé les routines au niveau de l'organisation. L'erreur apparaît lorsque vous essayez de créer ou d'exécuter une routine, y compris à partir de `/schedule` et de l'interface utilisateur [Routines](/fr/routines) sur claude.ai/code.

259

260```text theme={null}

261Routines are disabled by your organization's policy.

262```

263

264C'est un paramètre côté serveur, il ne peut donc pas être remplacé par les paramètres locaux, les variables d'environnement ou les drapeaux CLI.

265

266**Que faire :**

267

268* Demandez à votre administrateur d'activer le bouton bascule **Routines** sur [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code)

269* Pour les travaux ponctuels programmés qui ne nécessitent pas de routines au niveau de l'organisation, consultez [tâches programmées](/fr/scheduled-tasks)

270

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

256 272

257Votre connexion enregistrée n'est plus valide. Un jeton révoqué signifie que vous vous êtes déconnecté partout ou qu'un administrateur a supprimé l'accès ; un jeton expiré signifie que l'actualisation automatique a échoué en milieu de session.273Votre connexion enregistrée n'est plus valide. Un jeton révoqué signifie que vous vous êtes déconnecté partout ou qu'un administrateur a supprimé l'accès ; un jeton expiré signifie que l'actualisation automatique a échoué en milieu de session.

interactive-mode.md +1 −1

Details

289 289

290Après la réponse de Claude, les suggestions continuent à apparaître en fonction de votre historique de conversation, comme une étape de suivi d'une demande en plusieurs parties ou une continuation naturelle de votre flux de travail.290Après la réponse de Claude, les suggestions continuent à apparaître en fonction de votre historique de conversation, comme une étape de suivi d'une demande en plusieurs parties ou une continuation naturelle de votre flux de travail.

291 291

292* Appuyez sur **Tab** ou **Flèche droite** pour accepter la suggestion, ou appuyez sur **Entrée** pour accepter et soumettre292* Appuyez sur **Tab** ou **Flèche droite** pour placer la suggestion dans l'entrée d'invite, puis **Entrée** pour soumettre

293* Commencez à taper pour la rejeter293* Commencez à taper pour la rejeter

294 294

295La suggestion s'exécute en tant que demande en arrière-plan qui réutilise le cache d'invite de la conversation parent, le coût supplémentaire est donc minimal. Claude Code ignore la génération de suggestions lorsque le cache est froid pour éviter les coûts inutiles.295La suggestion s'exécute en tant que demande en arrière-plan qui réutilise le cache d'invite de la conversation parent, le coût supplémentaire est donc minimal. Claude Code ignore la génération de suggestions lorsque le cache est froid pour éviter les coûts inutiles.

mcp.md +2 −0

Details

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

266```266```

267 267

268Lors de la configuration des serveurs MCP via JSON dans `.mcp.json`, `~/.claude.json`, ou `claude mcp add-json`, le champ `type` accepte `streamable-http` comme alias pour `http`. La spécification MCP utilise le nom `streamable-http` pour ce transport, donc les configurations copiées à partir de la documentation du serveur fonctionnent sans modification.

269

268### Option 2 : Ajouter un serveur SSE distant270### Option 2 : Ajouter un serveur SSE distant

269 271

270<Warning>272<Warning>

permissions.md +7 −0

Details

210* `Edit(//tmp/scratch.txt)` : édite le chemin absolu `/tmp/scratch.txt`210* `Edit(//tmp/scratch.txt)` : édite le chemin absolu `/tmp/scratch.txt`

211* `Read(src/**)` : lit à partir de `<répertoire courant>/src/`211* `Read(src/**)` : lit à partir de `<répertoire courant>/src/`

212 212

213Une règle ne correspond qu'aux fichiers sous son ancrage, donc l'ancrage détermine jusqu'où une règle de refus s'étend. Les noms de fichiers nus suivent la sémantique gitignore et correspondent à n'importe quelle profondeur, donc `Read(.env)` et `Read(**/.env)` sont équivalents :

214

215| Règle de refus | Bloque | Ne bloque pas |

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

217| `Read(.env)` ou `Read(**/.env)` | tout `.env` au ou sous le répertoire courant | `.env` dans un répertoire parent ou un autre projet |

218| `Read(//**/.env)` | tout `.env` n'importe où sur le système de fichiers | rien ; la règle est ancrée à la racine du système de fichiers |

219

213<Note>220<Note>

214 Dans les modèles gitignore, `*` correspond aux fichiers dans un seul répertoire tandis que `**` correspond récursivement dans les répertoires. Pour autoriser tous les accès aux fichiers, utilisez simplement le nom de l'outil sans parenthèses : `Read`, `Edit` ou `Write`.221 Dans les modèles gitignore, `*` correspond aux fichiers dans un seul répertoire tandis que `**` correspond récursivement dans les répertoires. Pour autoriser tous les accès aux fichiers, utilisez simplement le nom de l'outil sans parenthèses : `Read`, `Edit` ou `Write`.

215</Note>222</Note>

plugins-reference.md +8 −3

Details

423 423

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

510 510

511### Règles de comportement des chemins511### Règles de comportement des chemins

512 512

513Pour `skills`, `commands`, `agents`, `outputStyles`, `experimental.themes` et `experimental.monitors`, un chemin personnalisé remplace le répertoire par défaut. Si le manifeste spécifie `skills`, le répertoire par défaut `skills/` n'est pas analysé ; si il spécifie `experimental.monitors`, le fichier par défaut `monitors/monitors.json` n'est pas chargé. Les [Hooks](#hooks), les [Serveurs MCP](#mcp-servers) et les [Serveurs LSP](#lsp-servers) ont une sémantique différente pour gérer plusieurs sources.513Qu'un chemin personnalisé remplace ou étend le répertoire par défaut du plugin dépend du champ :

514

515* **Remplace le répertoire par défaut** : `commands`, `agents`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Par exemple, quand le manifeste spécifie `commands`, le répertoire par défaut `commands/` n'est pas analysé. Pour conserver le répertoire par défaut et en ajouter d'autres, listez-le explicitement : `"commands": ["./commands/", "./extras/"]`

516* **S'ajoute au répertoire par défaut** : `skills`. Le répertoire par défaut `skills/` est toujours analysé, et les répertoires listés dans `skills` sont chargés à côté de lui

517* **Règles de fusion propres** : [hooks](#hooks), [Serveurs MCP](#mcp-servers), et [Serveurs LSP](#lsp-servers). Consultez chaque section pour savoir comment plusieurs sources se combinent

518

519Pour tous les champs de chemin :

514 520

515* Tous les chemins doivent être relatifs à la racine du plugin et commencer par `./`521* Tous les chemins doivent être relatifs à la racine du plugin et commencer par `./`

516* Les composants des chemins personnalisés utilisent les mêmes règles de nommage et d'espace de noms522* Les composants des chemins personnalisés utilisent les mêmes règles de nommage et d'espace de noms

517* Plusieurs chemins peuvent être spécifiés sous forme de tableaux523* Plusieurs chemins peuvent être spécifiés sous forme de tableaux

518* Pour conserver le répertoire par défaut et ajouter d'autres chemins pour les skills, les commandes, les agents ou les styles de sortie, incluez le répertoire par défaut dans votre tableau : `"skills": ["./skills/", "./extras/"]`

519* Quand un chemin de skill pointe vers un répertoire qui contient directement un `SKILL.md`, par exemple `"skills": ["./"]` pointant vers la racine du plugin, le champ frontmatter `name` dans `SKILL.md` détermine le nom d'invocation de la skill. Cela donne un nom stable indépendamment du répertoire d'installation. Si `name` n'est pas défini dans le frontmatter, le nom de base du répertoire est utilisé comme secours.524* Quand un chemin de skill pointe vers un répertoire qui contient directement un `SKILL.md`, par exemple `"skills": ["./"]` pointant vers la racine du plugin, le champ frontmatter `name` dans `SKILL.md` détermine le nom d'invocation de la skill. Cela donne un nom stable indépendamment du répertoire d'installation. Si `name` n'est pas défini dans le frontmatter, le nom de base du répertoire est utilisé comme secours.

520 525

521**Exemples de chemins** :526**Exemples de chemins** :

routines.md +8 −0

Details

22 22

23Les routines sont disponibles sur les plans Pro, Max, Team et Enterprise avec [Claude Code sur le web](/fr/claude-code-on-the-web) activé. Créez et gérez-les sur [claude.ai/code/routines](https://claude.ai/code/routines), ou à partir de la CLI avec `/schedule`.23Les routines sont disponibles sur les plans Pro, Max, Team et Enterprise avec [Claude Code sur le web](/fr/claude-code-on-the-web) activé. Créez et gérez-les sur [claude.ai/code/routines](https://claude.ai/code/routines), ou à partir de la CLI avec `/schedule`.

24 24

25Les administrateurs Team et Enterprise peuvent désactiver les routines pour tous les membres avec le bouton bascule Routines sur [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code). Lorsqu'elles sont désactivées, les routines existantes cessent de s'exécuter et les membres ne peuvent pas en créer de nouvelles.

25Cette page couvre la création d'une routine, la configuration de chaque type de déclencheur, la gestion des exécutions et la façon dont les limites d'utilisation s'appliquent.27Cette page couvre la création d'une routine, la configuration de chaque type de déclencheur, la gestion des exécutions et la façon dont les limites d'utilisation s'appliquent.

26 28

27## Exemples de cas d'usage29## Exemples de cas d'usage

360 362

361Les exécutions ponctuelles ne comptent pas par rapport au plafond quotidien des routines. Elles réduisent votre utilisation d'abonnement régulière comme toute autre session, mais elles sont exemptes de l'allocation quotidienne d'exécutions de routine par compte.363Les exécutions ponctuelles ne comptent pas par rapport au plafond quotidien des routines. Elles réduisent votre utilisation d'abonnement régulière comme toute autre session, mais elles sont exemptes de l'allocation quotidienne d'exécutions de routine par compte.

362 364

365## Dépannage

366

367### « Les routines sont désactivées par la politique de votre organisation »

368

369Votre administrateur Team ou Enterprise a probablement désactivé le bouton bascule **Routines** sur [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code). Il s'agit d'un paramètre d'organisation côté serveur, il ne peut donc pas être remplacé par votre configuration locale. Contactez votre administrateur pour demander que les routines soient activées pour votre organisation.

370

363## Ressources connexes371## Ressources connexes

364 372

365* [`/loop` et planification en session](/fr/scheduled-tasks) : planifiez les tâches locales dans une session CLI ouverte373* [`/loop` et planification en session](/fr/scheduled-tasks) : planifiez les tâches locales dans une session CLI ouverte

security.md +1 −1

Details

59* **Approbation des demandes réseau** : Les outils qui effectuent des demandes réseau nécessitent une approbation utilisateur par défaut59* **Approbation des demandes réseau** : Les outils qui effectuent des demandes réseau nécessitent une approbation utilisateur par défaut

60* **Fenêtres de contexte isolées** : Web fetch utilise une fenêtre de contexte séparée pour éviter d'injecter des prompts potentiellement malveillants60* **Fenêtres de contexte isolées** : Web fetch utilise une fenêtre de contexte séparée pour éviter d'injecter des prompts potentiellement malveillants

61* **Vérification de confiance** : Les premières exécutions de base de code et les nouveaux serveurs MCP nécessitent une vérification de confiance61* **Vérification de confiance** : Les premières exécutions de base de code et les nouveaux serveurs MCP nécessitent une vérification de confiance

~~62 * Remarque : La vérification de confiance est désactivée lors de l'exécution non-interactive avec le drapeau `-p`~~62 * Remarque : La vérification de confiance est désactivée lors de l'exécution non-interactive avec le drapeau `-p`. L'exception est [`--worktree`](/fr/worktrees), qui nécessite toujours que la confiance ait été acceptée pour le répertoire

63* **Détection d'injection de commande** : Les commandes bash suspectes nécessitent une approbation manuelle même si elles ont été précédemment autorisées63* **Détection d'injection de commande** : Les commandes bash suspectes nécessitent une approbation manuelle même si elles ont été précédemment autorisées

64* **Correspondance en cas d'échec fermé** : Les commandes non appariées par défaut nécessitent une approbation manuelle64* **Correspondance en cas d'échec fermé** : Les commandes non appariées par défaut nécessitent une approbation manuelle

65* **Descriptions en langage naturel** : Les commandes bash complexes incluent des explications pour la compréhension de l'utilisateur65* **Descriptions en langage naturel** : Les commandes bash complexes incluent des explications pour la compréhension de l'utilisateur

server-managed-settings.md +3 −2

Details

41 </Step>41 </Step>

42 42

43 <Step title="Définir vos paramètres">43 <Step title="Définir vos paramètres">

44 Ajoutez votre configuration en JSON. Tous les [paramètres disponibles dans `settings.json`](/fr/settings#available-settings) sont pris en charge, y compris les [hooks](/fr/hooks), les [variables d'environnement](/fr/env-vars) et les [paramètres réservés à la gestion](/fr/permissions#managed-only-settings) comme `allowManagedPermissionRulesOnly`.44 Ajoutez votre configuration en JSON. Tous les [paramètres disponibles dans `settings.json`](/fr/settings#available-settings) sont pris en charge, sauf ceux limités à la livraison de politique au niveau du système d'exploitation ; consultez [Limitations actuelles](#current-limitations) pour cette courte liste. Cela inclut les [hooks](/fr/hooks), les [variables d'environnement](/fr/env-vars) et les [paramètres réservés à la gestion](/fr/permissions#managed-only-settings) comme `allowManagedPermissionRulesOnly`.

45 45

46 Cet exemple applique une liste de refus de permissions, empêche les utilisateurs de contourner les permissions et restreint les règles de permission à celles définies dans les paramètres gérés :46 Cet exemple applique une liste de refus de permissions, empêche les utilisateurs de contourner les permissions et restreint les règles de permission à celles définies dans les paramètres gérés :

47 47

93 }93 }

94 ```94 ```

95 95

96 Parce que les hooks exécutent des commandes shell, les utilisateurs voient une [boîte de dialogue d'approbation de sécurité](#security-approval-dialogs) avant qu'elles ne soient appliquées. Consultez [Configurer le mode auto](/fr/auto-mode-config) pour savoir comment les entrées `autoMode` affectent ce que le classificateur bloque et les avertissements importants concernant les champs `allow` et `soft_deny`.96 Parce que les hooks exécutent des commandes shell, les utilisateurs voient une [boîte de dialogue d'approbation de sécurité](#security-approval-dialogs) avant qu'elles ne soient appliquées. Consultez [Configurer le mode auto](/fr/auto-mode-config) pour savoir comment les entrées `autoMode` affectent ce que le classificateur bloque et les avertissements importants concernant les champs `environment`, `allow`, `soft_deny` et `hard_deny`.

97 </Step>97 </Step>

98 98

99 <Step title="Enregistrer et déployer">99 <Step title="Enregistrer et déployer">

124 124

125* Les paramètres s'appliquent uniformément à tous les utilisateurs de l'organisation. Les configurations par groupe ne sont pas encore prises en charge.125* Les paramètres s'appliquent uniformément à tous les utilisateurs de l'organisation. Les configurations par groupe ne sont pas encore prises en charge.

126* Les [configurations de serveur MCP](/fr/mcp#managed-mcp-configuration) ne peuvent pas être distribuées via les paramètres gérés par le serveur.126* Les [configurations de serveur MCP](/fr/mcp#managed-mcp-configuration) ne peuvent pas être distribuées via les paramètres gérés par le serveur.

127* Les paramètres limités aux sources de politique au niveau du système d'exploitation, tels que `policyHelper` et `wslInheritsWindowsSettings`, ne sont pas respectés. Déployez-les plutôt via MDM ou un fichier `managed-settings.json` système.

127 128

128## Livraison des paramètres129## Livraison des paramètres

129 130

settings.md +28 −1

Details

169| `attribution` | Personnalisez l'attribution pour les commits git et les pull requests. Voir [Paramètres d'attribution](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |169| `attribution` | Personnalisez l'attribution pour les commits git et les pull requests. Voir [Paramètres d'attribution](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |

170| `autoMemoryDirectory` | Répertoire personnalisé pour le stockage de la [mémoire automatique](/fr/memory#storage-location). Accepte un chemin absolu ou un chemin préfixé par `~/`. Accepté à partir des paramètres de politique et utilisateur, et à partir de l'indicateur `--settings`. Non accepté à partir des paramètres de projet ou locaux, car un référentiel cloné pourrait fournir l'un ou l'autre fichier pour rediriger les écritures de mémoire vers des emplacements sensibles | `"~/my-memory-dir"` |170| `autoMemoryDirectory` | Répertoire personnalisé pour le stockage de la [mémoire automatique](/fr/memory#storage-location). Accepte un chemin absolu ou un chemin préfixé par `~/`. Accepté à partir des paramètres de politique et utilisateur, et à partir de l'indicateur `--settings`. Non accepté à partir des paramètres de projet ou locaux, car un référentiel cloné pourrait fournir l'un ou l'autre fichier pour rediriger les écritures de mémoire vers des emplacements sensibles | `"~/my-memory-dir"` |

171| `autoMemoryEnabled` | Activer la [mémoire automatique](/fr/memory#enable-or-disable-auto-memory). Quand `false`, Claude ne lit pas et n'écrit pas dans le répertoire de mémoire automatique. Par défaut : `true`. Vous pouvez également basculer ceci avec `/memory` pendant une session. Pour désactiver via une variable d'environnement, définissez [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/fr/env-vars) dans `env` | `false` |171| `autoMemoryEnabled` | Activer la [mémoire automatique](/fr/memory#enable-or-disable-auto-memory). Quand `false`, Claude ne lit pas et n'écrit pas dans le répertoire de mémoire automatique. Par défaut : `true`. Vous pouvez également basculer ceci avec `/memory` pendant une session. Pour désactiver via une variable d'environnement, définissez [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/fr/env-vars) dans `env` | `false` |

172| `autoMode` | Personnalisez ce que le classificateur du [mode auto](/fr/permission-modes#eliminate-prompts-with-auto-mode) bloque et autorise. Contient les tableaux `environment`, `allow`, et `soft_deny` de règles en prose. Incluez la chaîne littérale `"$defaults"` dans un tableau pour hériter des règles intégrées à cette position. Voir [Configurer le mode auto](/fr/auto-mode-config). Non lu à partir des paramètres de projet partagés | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |172| `autoMode` | Personnalisez ce que le classificateur du [mode auto](/fr/permission-modes#eliminate-prompts-with-auto-mode) bloque et autorise. Contient les tableaux `environment`, `allow`, `soft_deny`, et `hard_deny` de règles en prose. Incluez la chaîne littérale `"$defaults"` dans un tableau pour hériter des règles intégrées à cette position. Voir [Configurer le mode auto](/fr/auto-mode-config). Non lu à partir des paramètres de projet partagés | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |

173| `autoScrollEnabled` | Dans le [rendu fullscreen](/fr/fullscreen), suivre la nouvelle sortie vers le bas de la conversation. Par défaut : `true`. Apparaît dans `/config` comme **Auto-scroll**. Les invites de permission font toujours défiler dans la vue quand ceci est désactivé | `false` |173| `autoScrollEnabled` | Dans le [rendu fullscreen](/fr/fullscreen), suivre la nouvelle sortie vers le bas de la conversation. Par défaut : `true`. Apparaît dans `/config` comme **Auto-scroll**. Les invites de permission font toujours défiler dans la vue quand ceci est désactivé | `false` |

174| `autoUpdatesChannel` | Canal de version à suivre pour les mises à jour. Utilisez `"stable"` pour une version généralement une semaine ancienne et qui ignore les versions avec des régressions majeures, ou `"latest"` (par défaut) pour la version la plus récente. Pour désactiver complètement les auto-mises à jour, définissez [`DISABLE_AUTOUPDATER`](/fr/setup#disable-auto-updates) dans `env` | `"stable"` |174| `autoUpdatesChannel` | Canal de version à suivre pour les mises à jour. Utilisez `"stable"` pour une version généralement une semaine ancienne et qui ignore les versions avec des régressions majeures, ou `"latest"` (par défaut) pour la version la plus récente. Pour désactiver complètement les auto-mises à jour, définissez [`DISABLE_AUTOUPDATER`](/fr/setup#disable-auto-updates) dans `env` | `"stable"` |

175| `availableModels` | Restreindre les modèles que les utilisateurs peuvent sélectionner via `/model`, `--model`, ou `ANTHROPIC_MODEL`. N'affecte pas l'option Par défaut. Voir [Restreindre la sélection de modèle](/fr/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |175| `availableModels` | Restreindre les modèles que les utilisateurs peuvent sélectionner via `/model`, `--model`, ou `ANTHROPIC_MODEL`. N'affecte pas l'option Par défaut. Voir [Restreindre la sélection de modèle](/fr/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |

217| `pluginTrustMessage` | (Paramètres gérés uniquement) Message personnalisé ajouté à l'avertissement de confiance du plugin affiché avant l'installation. Utilisez ceci pour ajouter du contexte spécifique à l'organisation, par exemple pour confirmer que les plugins de votre marketplace interne sont vérifiés. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Paramètres gérés uniquement) Message personnalisé ajouté à l'avertissement de confiance du plugin affiché avant l'installation. Utilisez ceci pour ajouter du contexte spécifique à l'organisation, par exemple pour confirmer que les plugins de votre marketplace interne sont vérifiés. | `"All plugins from our marketplace are approved by IT"` |

218| `policyHelper` | {/* min-version: 2.1.136 */}Exécutable déployé par l'administrateur qui calcule les paramètres gérés dynamiquement au démarrage. Honoré uniquement à partir de MDM ou d'un fichier `managed-settings.json` système. Voir [Calculer les paramètres gérés avec un assistant de politique](#compute-managed-settings-with-a-policy-helper). Nécessite Claude Code v2.1.136 ou ultérieur | `{"path": "/usr/local/bin/claude-policy"}` |

218| `preferredNotifChannel` | Méthode pour les notifications de tâche terminée et d'invite de permission : `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, ou `"notifications_disabled"`. Par défaut : `"auto"`, qui envoie une notification de bureau dans iTerm2, Ghostty, et Kitty et ne fait rien dans les autres terminaux. Définir à `"terminal_bell"` pour sonner le caractère de cloche dans n'importe quel terminal. Apparaît dans `/config` comme **Notifications**. Voir [Obtenir une cloche de terminal ou une notification](/fr/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |219| `preferredNotifChannel` | Méthode pour les notifications de tâche terminée et d'invite de permission : `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, ou `"notifications_disabled"`. Par défaut : `"auto"`, qui envoie une notification de bureau dans iTerm2, Ghostty, et Kitty et ne fait rien dans les autres terminaux. Définir à `"terminal_bell"` pour sonner le caractère de cloche dans n'importe quel terminal. Apparaît dans `/config` comme **Notifications**. Voir [Obtenir une cloche de terminal ou une notification](/fr/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |

220| `prUrlTemplate` | Modèle d'URL pour le badge PR affiché dans le pied de page et dans les résumés de résultats d'outils. Substitue `{host}`, `{owner}`, `{repo}`, `{number}`, et `{url}` à partir de l'URL PR rapportée par `gh`. Utilisez pour pointer les liens PR vers un outil d'examen de code interne au lieu de `github.com`. N'affecte pas les autolinks `#123` dans la prose de Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |221| `prUrlTemplate` | Modèle d'URL pour le badge PR affiché dans le pied de page et dans les résumés de résultats d'outils. Substitue `{host}`, `{owner}`, `{repo}`, `{number}`, et `{url}` à partir de l'URL PR rapportée par `gh`. Utilisez pour pointer les liens PR vers un outil d'examen de code interne au lieu de `github.com`. N'affecte pas les autolinks `#123` dans la prose de Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |

470}471}

471```472```

472 473

474### Calculer les paramètres gérés avec un assistant de politique

475

476Le paramètre `policyHelper` pointe vers un exécutable qui calcule les paramètres gérés au démarrage, afin que les administrateurs puissent dériver la politique de la posture de l'appareil, de l'identité, ou d'un service distant au lieu d'un fichier statique. Configurez-le à partir de MDM ou d'un fichier `managed-settings.json` système. Claude Code ignore `policyHelper` quand il apparaît dans n'importe quelle autre portée, y compris les paramètres utilisateur, les paramètres de projet, la ruche de registre HKCU, et les [paramètres gérés par le serveur](/fr/server-managed-settings).

477

478Le paramètre accepte ces clés :

479

480| Clé | Type | Description |

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

482| `path` | string | Chemin absolu vers l'exécutable d'assistance |

483| `timeoutMs` | number | Combien de temps attendre l'assistant avant de traiter l'exécution comme échouée |

484| `refreshIntervalMs` | number | Fréquence à laquelle réexécuter l'assistant en arrière-plan. Définir à `0` pour désactiver l'actualisation, ou à au moins `60000` |

485

486L'assistant écrit une enveloppe JSON vers stdout. Mettez les paramètres sous une clé `managedSettings` plutôt qu'au niveau supérieur, car un objet de paramètres nu analyse avec `managedSettings` non défini et n'applique rien :

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

498Quand l'assistant émet `managedSettings`, cet objet remplace les paramètres gérés basés sur fichier pour l'exécution. Quand l'assistant se termine avec un code non zéro au démarrage, Claude Code imprime l'erreur et refuse de démarrer, donc un assistant qui a besoin de résilience de panne devrait servir à partir de son propre cache et se terminer avec `0`.

499

473### Précédence des paramètres500### Précédence des paramètres

474 501

475Les paramètres s'appliquent dans l'ordre de précédence. Du plus élevé au plus bas :502Les paramètres s'appliquent dans l'ordre de précédence. Du plus élevé au plus bas :

whats-new.md +17 −1

Details

8 8

9Le digest hebdomadaire pour développeurs met en évidence les fonctionnalités les plus susceptibles de changer votre façon de travailler. Chaque entrée inclut du code exécutable, une courte démo et un lien vers la documentation complète. Pour chaque correction de bug et amélioration mineure, consultez le [changelog](/fr/changelog).9Le digest hebdomadaire pour développeurs met en évidence les fonctionnalités les plus susceptibles de changer votre façon de travailler. Chaque entrée inclut du code exécutable, une courte démo et un lien vers la documentation complète. Pour chaque correction de bug et amélioration mineure, consultez le [changelog](/fr/changelog).

10 10

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

12 **Les plugins se chargent à partir d'archives `.zip` et d'URL** : `--plugin-dir` accepte maintenant les fichiers `.zip`, et `--plugin-url` récupère une archive de plugin pour la session actuelle.

14 Également cette semaine : **`worktree.baseRef`** choisit si les nouveaux worktrees se branchent à partir de la valeur par défaut distante ou du `HEAD` local ; **les règles de refus dur en mode auto** bloquent les actions sans condition indépendamment des exceptions d'autorisation ; et **les hooks voient le niveau d'effort actif** via `effort.level` et `$CLAUDE_EFFORT`.

16 [Lire le digest de la Week 19 →](/fr/whats-new/2026-w19)

17</Update>

19<Update label="Week 18" description="27 avril – 1er mai 2026" tags={["v2.1.120–v2.1.126"]}>

20 **Windows sans Git Bash** : Git pour Windows n'est plus requis, et Claude Code utilise PowerShell comme outil shell en l'absence de Bash.

22 Également cette semaine : **`claude ultrareview`** apporte l'examen de code cloud à CI et aux scripts ; **`claude project purge`** nettoie l'état local d'un projet ; et coller une **URL de PR dans `/resume`** trouve la session qui l'a créée.

24 [Lire le digest de la Week 18 →](/fr/whats-new/2026-w18)

25</Update>

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

12 **`/ultrareview`** s'ouvre en tant qu'aperçu de recherche public : une flotte d'agents chasseurs de bugs s'exécute dans le cloud et les résultats reviennent automatiquement dans votre CLI ou Desktop.28 **`/ultrareview`** s'ouvre en tant qu'aperçu de recherche public : une flotte d'agents chasseurs de bugs s'exécute dans le cloud et les résultats reviennent automatiquement dans votre CLI ou Desktop.

13 29

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

20 **Claude Opus 4.7** arrive en tant que nouveau défaut sur Max et Team Premium, avec un nouveau niveau d'effort `xhigh` qui est le paramètre recommandé pour la plupart des travaux de codage et un curseur `/effort` interactif pour l'ajuster.36 **Claude Opus 4.7** arrive en tant que nouveau défaut sur Max et Team Premium, avec un nouveau niveau d'effort `xhigh` qui est le paramètre recommandé pour la plupart des travaux de codage et un curseur `/effort` interactif pour l'ajuster.

21 37

22 Également cette semaine : **Routines** sur Claude Code sur le web déclenche des agents cloud modélisés à partir d'un calendrier, d'un événement GitHub ou d'un appel API ; `/ultrareview` exécute un examen de code multi-agent parallèle dans le cloud ; `/usage` affiche ce qui pilote vos limites ; et la CLI passe à des binaires natifs.38 Également cette semaine : **Routines** sur Claude Code sur le web déclenche des agents cloud modélisés à partir d'un calendrier, d'un événement GitHub ou d'un appel API ; **notifications push mobiles** vous pingent sur votre téléphone quand une tâche longue se termine ou que Claude a besoin de vous ; `/usage` affiche ce qui pilote vos limites ; et la CLI passe à des binaires natifs.

23 39

24 [Lire le digest de la Week 16 →](/fr/whats-new/2026-w16)40 [Lire le digest de la Week 16 →](/fr/whats-new/2026-w16)

25</Update>41</Update>

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

Details

4 4

5# Semaine 16 · 13–17 avril 20265# Semaine 16 · 13–17 avril 2026

6 6

7> Claude Opus 4.7 avec le nouveau niveau d'effort xhigh, Routines sur Claude Code sur le web, /ultrareview pour l'examen du code cloud, une ventilation /usage qui montre ce qui limite votre utilisation, et les binaires natifs remplaçant le JavaScript fourni.7> Claude Opus 4.7 avec le nouveau niveau d'effort xhigh, Routines sur Claude Code sur le web, notifications push mobiles qui vous signalent sur votre téléphone quand Claude a besoin de vous, une ventilation /usage qui montre ce qui limite votre utilisation, et les binaires natifs remplaçant le JavaScript fourni.

8 8

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

10 <span>Versions <a href="/fr/docs/changelog#2-1-105">v2.1.105 → v2.1.113</a></span>10 <span>Versions <a href="/fr/docs/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">Notifications push mobiles</span>

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

78 </div>78 </div>

79 79

80 <p className="digest-feature-lede">Examen complet du code dans le cloud. Ultrareview distribue votre branche sur plusieurs relecteurs parallèles sur Claude Code sur le web, exécute une passe de critique contradictoire sur chaque constatation et retourne un rapport de constatations vérifiées tandis que votre terminal reste libre. Appelez-la sans arguments pour examiner votre branche actuelle, ou passez un numéro de PR pour récupérer et examiner cette PR. La boîte de dialogue de lancement affiche désormais un diffstat pour que vous sachiez ce qui va être envoyé avant de confirmer.</p>80 <p className="digest-feature-lede">Avec <a href="/fr/docs/remote-control">Remote Control</a> connecté, Claude peut envoyer une notification push sur votre téléphone quand une tâche longue se termine ou quand il a besoin d'une décision pour continuer. Activez-la avec « Envoyer une notification quand Claude décide » dans <code>/config</code>, ou demandez-en une dans votre invite. Utile quand vous lancez une exécution d'agent longue et que vous voulez vous éloigner du terminal.</p>

81 81

~~82 <p className="digest-feature-try">Examinez la branche sur laquelle vous êtes :</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">Ou pointez-la vers une PR :</p>~~86 <p className="digest-feature-try">Demandez à Claude de vous signaler quand c'est terminé :</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="/fr/docs/ultrareview">Guide Ultrareview</a>~~92 <a className="digest-feature-link" href="/fr/docs/remote-control#mobile-push-notifications">Remote Control : notifications push mobiles</a>

95</div>93</div>

96 94

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

116 <p className="digest-wins-title">Autres améliorations</p>114 <p className="digest-wins-title">Autres améliorations</p>

117 115

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

117 <div>Nouveau <a href="/fr/docs/ultrareview"><code>/ultrareview</code></a> : examen complet du code dans le cloud utilisant l'analyse multi-agents parallèles et une passe de critique contradictoire. Exécutez-le sans arguments pour examiner votre branche actuelle, ou <code>/ultrareview \<PR#></code> pour une PR spécifique</div>

119 <div><a href="/fr/docs/permission-modes#eliminate-prompts-with-auto-mode">Le mode Auto</a> est désormais disponible pour les abonnés Max sur Opus 4.7, et l'indicateur <code>--enable-auto-mode</code> n'est plus requis</div>118 <div><a href="/fr/docs/permission-modes#eliminate-prompts-with-auto-mode">Le mode Auto</a> est désormais disponible pour les abonnés Max sur Opus 4.7, et l'indicateur <code>--enable-auto-mode</code> n'est plus requis</div>

120 <div><a href="/fr/docs/interactive-mode#session-recap">Le résumé de session</a> affiche un résumé d'une ligne de ce qui s'est passé pendant votre absence ; exécutez <code>/recap</code> à la demande ou désactivez-le depuis <code>/config</code></div>119 <div><a href="/fr/docs/interactive-mode#session-recap">Le résumé de session</a> affiche un résumé d'une ligne de ce qui s'est passé pendant votre absence ; exécutez <code>/recap</code> à la demande ou désactivez-le depuis <code>/config</code></div>

121 <div>Nouvelle commande <code>/tui</code> et paramètre <code>tui</code> pour basculer entre le rendu classique et sans scintillement en cours de conversation ; la vue de focus a été déplacée de <code>Ctrl+O</code> vers sa propre commande <code>/focus</code></div>120 <div>Nouvelle commande <code>/tui</code> et paramètre <code>tui</code> pour basculer entre le rendu classique et sans scintillement en cours de conversation ; la vue de focus a été déplacée de <code>Ctrl+O</code> vers sa propre commande <code>/focus</code></div>

122 <div>Outil de notification push : avec <a href="/fr/docs/remote-control">Remote Control</a> connecté et « Envoyer une notification quand Claude décide » activé, Claude peut vous faire signe sur votre téléphone quand il a besoin de vous</div>

123 <div>Les plugins peuvent livrer des observateurs en arrière-plan via une clé de manifeste de niveau supérieur <code>monitors</code> qui s'arme automatiquement au démarrage de la session ou à l'invocation de la compétence</div>121 <div>Les plugins peuvent livrer des observateurs en arrière-plan via une clé de manifeste de niveau supérieur <code>monitors</code> qui s'arme automatiquement au démarrage de la session ou à l'invocation de la compétence</div>

124 <div>Option « Auto (correspondre au terminal) » dans <code>/theme</code> qui suit le mode sombre/clair de votre terminal</div>122 <div>Option « Auto (correspondre au terminal) » dans <code>/theme</code> qui suit le mode sombre/clair de votre terminal</div>

125 <div><code>/fewer-permission-prompts</code> analyse vos transcriptions pour les appels Bash et MCP courants en lecture seule et propose une liste d'autorisation pour <code>.claude/settings.json</code></div>123 <div><code>/fewer-permission-prompts</code> analyse vos transcriptions pour les appels Bash et MCP courants en lecture seule et propose une liste d'autorisation pour <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# Semaine 18 · 27 avril – 1er mai 2026

7> Claude Code sur Windows s'exécute sans Git Bash, claude auth login accepte un code OAuth collé lorsque le rappel du navigateur ne peut pas atteindre localhost, claude project purge nettoie l'état local par projet, et coller une URL de PR dans /resume trouve la session qui l'a créée.

9<div className="digest-meta">

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

11 <span>4 fonctionnalités · 27 avril – 1er mai</span>

12</div>

14<div className="digest-feature">

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

16 <span className="digest-feature-title">Se connecter sans rappel du navigateur</span>

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

18 </div>

20 <p className="digest-feature-lede"><code>claude auth login</code> accepte maintenant le code OAuth collé directement dans le terminal lorsque le rappel du navigateur ne peut pas atteindre localhost. Cela couvre WSL2, les sessions SSH et les conteneurs, où la redirection vers un port local ne fonctionne pas. La même version corrige également les délais d'expiration de connexion sur les connexions lentes ou proxifiées et dans les devcontainers IPv6 uniquement.</p>

22 <p className="digest-feature-try">Connectez-vous, puis collez le code du navigateur :</p>

24 ```bash theme={null}

25 claude auth login

26 ```

28 <a className="digest-feature-link" href="/fr/docs/cli-reference#cli-commands">Référence 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">Supprimez tout l'état Claude Code pour un projet : transcriptions, tâches, historique des fichiers et l'entrée de configuration du projet. Supporte `--dry-run` pour prévisualiser, `-y`/`--yes` pour ignorer la confirmation, `-i`/`--interactive` pour choisir, et `--all` pour effacer tous les projets.</p>

39 <p className="digest-feature-try">Prévisualisez ce qui serait supprimé :</p>

41 ```bash theme={null}

42 claude project purge --dry-run

43 ```

45 <p className="digest-feature-try">Puis exécutez-le pour de vrai :</p>

47 ```bash theme={null}

48 claude project purge

49 ```

51 <a className="digest-feature-link" href="/fr/docs/cli-reference">Référence CLI</a>

52</div>

54<div className="digest-feature">

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

56 <span className="digest-feature-title">Reprendre par URL de PR</span>

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

58 </div>

60 <p className="digest-feature-lede">Lorsque vous créez une demande de tirage avec <code>gh pr create</code>, Claude Code la lie à la session qui l'a produite. Maintenant, vous pouvez revenir à cette session à partir de l'URL de PR seule, sans vous souvenir de son nom.</p>

62 <p className="digest-feature-try">Ouvrez le sélecteur de session :</p>

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

65 > /resume

66 ```

68 <p className="digest-feature-try">Collez l'URL de PR dans le sélecteur. Le premier caractère du collage vous fait entrer en mode recherche, et la liste se filtre à la session qui a créé cette PR. Appuyez sur Entrée pour la reprendre. Les URL de demandes de tirage et de fusion GitHub, GitHub Enterprise, GitLab et Bitbucket fonctionnent toutes.</p>

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

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

72 ```

74 <p className="digest-feature-try">Pour ignorer le sélecteur, passez plutôt le numéro de PR sur la ligne de commande :</p>

76 ```bash theme={null}

77 claude --from-pr 1234

78 ```

80 <a className="digest-feature-link" href="/fr/docs/sessions#use-the-session-picker">Sessions : utiliser le sélecteur de session</a>

81</div>

83<div className="digest-feature">

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

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

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

87 </div>

89 <p className="digest-feature-lede">Git pour Windows n'est plus requis. Lorsque Bash est absent, Claude Code utilise PowerShell comme outil shell, et lorsque l'outil PowerShell est activé, il est traité comme le shell principal. PowerShell 7 installé via le Microsoft Store, MSI sans PATH, ou un outil global <code>.NET</code> est maintenant détecté automatiquement.</p>

91 <a className="digest-feature-link" href="/fr/docs/setup">Guide de configuration</a>

92</div>

94<div className="digest-wins">

95 <p className="digest-wins-title">Autres améliorations</p>

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

98 <div>Les serveurs MCP peuvent refuser le report de recherche d'outils avec <code>alwaysLoad: true</code> dans leur configuration afin que tous les outils de ce serveur soient toujours disponibles</div>

99 <div>Nouveau <code>claude plugin prune</code> supprime les dépendances de plugin auto-installées orphelines, et <code>plugin uninstall --prune</code> en cascade</div>

100 <div><code>/skills</code> a maintenant une boîte de recherche de type-pour-filtrer afin que vous puissiez trouver une compétence dans une longue liste sans faire défiler</div>

101 <div>Les hooks <code>PostToolUse</code> peuvent remplacer la sortie d'outil pour n'importe quel outil via <code>hookSpecificOutput.updatedToolOutput</code>, pas seulement les outils MCP</div>

102 <div>Nouvelle sous-commande <a href="/fr/docs/ultrareview"><code>claude ultrareview</code></a> exécute <code>/ultrareview</code> de manière non-interactive à partir de CI ou de scripts : imprime les résultats sur stdout (<code>--json</code> pour la sortie brute) et quitte 0 à la fin ou 1 en cas d'échec</div>

103 <div><code>--dangerously-skip-permissions</code> contourne maintenant les invites pour les écritures dans <code>.claude/</code>, <code>.git/</code>, <code>.vscode/</code>, les fichiers de configuration shell et autres chemins précédemment protégés, tandis que les commandes de suppression catastrophique continuent à inviter comme filet de sécurité</div>

104 <div>Le sélecteur <code>/model</code> peut lister les modèles à partir du point de terminaison <code>/v1/models</code> de votre passerelle lorsque <code>ANTHROPIC\_BASE\_URL</code> pointe vers une passerelle compatible Anthropic ; acceptez avec <code>CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1</code> depuis v2.1.129</div>

105 <div>Les serveurs MCP qui rencontrent une erreur transitoire lors du démarrage réessaient maintenant jusqu'à 3 fois au lieu de rester déconnectés</div>

106 <div><code>ANTHROPIC\_BEDROCK\_SERVICE\_TIER</code> sélectionne un niveau de service Bedrock : <code>default</code>, <code>flex</code>, ou <code>priority</code></div>

107 <div><code>/terminal-setup</code> active le paramètre d'accès au presse-papiers d'iTerm2 afin que <code>/copy</code> fonctionne, y compris depuis tmux</div>

108 <div>Vertex AI supporte maintenant la Fédération d'identité de charge de travail basée sur les certificats X.509 (mTLS ADC)</div>

109 <div>Corrections importantes des fuites mémoire : sessions riches en images, <code>/usage</code> sur les historiques de transcription volumineux, et outils de longue durée sans événements de progression</div>

110 </div>

111</div>

112

113[Journal des modifications complet pour v2.1.120–v2.1.126 →](/fr/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# Semaine 19 · 4–8 mai 2026

7> Chargez les plugins à partir d'archives .zip et d'URL, recherchez l'historique des commandes dans tous les projets avec Ctrl+R, créez de nouvelles worktrees à partir de HEAD local ou de la branche par défaut distante, et bloquez les actions sans condition avec les règles de refus inconditionnels en mode auto.

9<div className="digest-meta">

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

11 <span>2 fonctionnalités · 4–8 mai</span>

12</div>

14<div className="digest-feature">

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

16 <span className="digest-feature-title">Plugins à partir d'archives .zip et d'URL</span>

17 </div>

19 <p className="digest-feature-lede"><code>--plugin-dir</code> accepte désormais une archive de plugin <code>.zip</code> en plus d'un répertoire, et le nouveau drapeau <code>--plugin-url</code> récupère une archive de plugin à partir d'une URL pour la session actuelle. Utile pour tester un plugin avant de l'ajouter à une marketplace, ou pour livrer des plugins internes à partir d'un magasin d'artefacts.</p>

21 <p className="digest-feature-try">Chargez un plugin directement à partir d'une 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="/fr/plugins">Guide des plugins</a>

28</div>

30<div className="digest-feature">

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

32 <span className="digest-feature-title">Recherche d'historique dans tous vos projets</span>

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

34 </div>

36 <p className="digest-feature-lede">La recherche inversée <code>Ctrl+R</code> s'applique désormais par défaut à tous les invites dans tous les projets, rétablissant le comportement d'avant v2.1.124. Appuyez sur <code>Ctrl+S</code> pendant la recherche pour revenir au projet ou à la session actuelle. Pratique quand vous vous souvenez d'une commande que vous avez exécutée dans un autre dépôt la semaine dernière et que vous ne voulez pas la chercher.</p>

38 <a className="digest-feature-link" href="/fr/interactive-mode#command-history">Mode interactif : historique des commandes</a>

39</div>

41<div className="digest-wins">

42 <p className="digest-wins-title">Autres améliorations</p>

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

45 <div>Le nouveau paramètre <code>worktree.baseRef</code> (<code>fresh</code> | <code>head</code>) contrôle si <code>--worktree</code>, l'outil <code>EnterWorktree</code> et les worktrees d'isolation d'agent créent une branche à partir de la branche par défaut distante ou de <code>HEAD</code> local ; la valeur par défaut <code>fresh</code> maintient les commits non poussés en dehors des nouvelles worktrees</div>

46 <div>Les nouvelles règles <code>settings.autoMode.hard\_deny</code> bloquent les actions correspondantes sans condition en mode auto, indépendamment des exceptions d'autorisation, pour les actions qui ne doivent jamais s'exécuter automatiquement même lorsque des règles d'autorisation plus larges s'appliquent</div>

47 <div>Les hooks reçoivent désormais le niveau d'effort actif via le champ d'entrée JSON <code>effort.level</code> et la variable d'environnement <code>$CLAUDE_EFFORT</code>, et les commandes de l'outil Bash peuvent lire <code>$CLAUDE\_EFFORT</code></div>

48 <div><code>CLAUDE\_CODE\_DISABLE\_ALTERNATE\_SCREEN=1</code> désactive le rendu du rendu en écran alternatif plein écran et conserve la conversation dans le défilement natif du terminal</div>

49 <div><code>CLAUDE\_CODE\_PACKAGE\_MANAGER\_AUTO\_UPDATE</code> permet aux installations Homebrew ou WinGet d'exécuter la mise à niveau en arrière-plan et de demander un redémarrage</div>

50 <div><code>CLAUDE\_CODE\_SESSION\_ID</code> se trouve désormais dans l'environnement du sous-processus de l'outil Bash, correspondant à <code>session\_id</code> transmis aux hooks</div>

51 <div><code>/mcp</code> affiche désormais le nombre d'outils pour les serveurs connectés et signale les serveurs qui se sont connectés avec 0 outil</div>

52 <div><code>--channels</code> fonctionne désormais avec l'authentification par console (clé API)</div>

53 <div>Les sous-processus tels que Bash, hooks, MCP et LSP n'héritent plus des variables d'environnement <code>OTEL\_\*</code>, donc les applications instrumentées par OTEL exécutées via l'outil Bash ne récupèrent plus le point de terminaison OTLP propre de la CLI</div>

54 <div>Les résumés de progression des sous-agents atteignent désormais le cache d'invite, réduisant le coût des jetons <code>cache\_creation</code> d'environ 3x</div>

55 <div>Plusieurs correctifs de fiabilité OAuth et des identifiants : les sessions parallèles ne se terminent plus à 401 après une course de jeton d'actualisation, les jetons d'actualisation OAuth MCP ne sont plus perdus lorsque plusieurs serveurs s'actualisent simultanément, et une boucle de connexion rare due à une écriture d'identifiants simultanée est corrigée</div>

56 <div>La nouvelle clé d'administration <code>parentSettingsBehavior</code> permet aux administrateurs d'opter pour le SDK <code>managedSettings</code> dans la fusion de politique</div>

57 </div>

58</div>

60[Journal des modifications complet pour v2.1.128–v2.1.136 →](/fr/changelog#2-1-128)

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