Documentation — Spybara

agent-sdk/mcp.md +1 −1

Details

309 </Tab>309 </Tab>

310</Tabs>310</Tabs>

311 311

312Per HTTP (non-streaming), utilizza `"type": "http"` invece.312Per il trasporto HTTP in streaming, utilizza `"type": "http"` invece. Nei file di configurazione `.mcp.json` e altri file JSON, `"streamable-http"` è accettato come alias per `"http"`. L'opzione programmatica `mcpServers` accetta solo `"http"`.

313 313

314### Server MCP SDK314### Server MCP SDK

315 315

agent-sdk/python.md +3 −1

Details

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

313Risolve le impostazioni effettive di Claude Code per una determinata directory utilizzando lo stesso motore di merge della CLI, senza generare la CLI Claude. Utilizzalo per ispezionare quale configurazione una chiamata `query()` vedrebbe prima di invocarne una.

314

315<Note>

316 Questa funzione è in fase alpha e la sua API potrebbe cambiare prima della stabilizzazione. Legge le fonti MDM, inclusi plist macOS e Windows HKLM/HKCU, per la parità con l'avvio della CLI, ma non esegue il subprocess `policyHelper` configurato dall'amministratore. Il campo `permissions.defaultMode` viene restituito così com'è da tutti i livelli incluse le impostazioni del progetto. Il filtro di fiducia che la CLI applica prima di onorare i modi di autorizzazione crescenti non viene applicato.

317</Note>

318

319```typescript theme={null}

320function resolveSettings(

321 options?: ResolveSettingsOptions

322): Promise<ResolvedSettings>;

323```

324

325#### Parametri

326

327`resolveSettings()` accetta un singolo oggetto di opzioni. Tutti i campi sono opzionali.

328

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

332| `options.settingSources` | [`SettingSource`](#settingsource)`[]` | Tutte le fonti | Quali fonti del filesystem caricare. Passa `[]` per saltare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita si caricano in tutti i casi |

333| `options.managedSettings` | `Settings` | `undefined` | Impostazioni della politica restrittiva unite al livello di precedenza della politica gestita. Le chiavi non restrittive come `model` vengono silenziosamente eliminate |

335

336#### Tipo di ritorno: `ResolvedSettings`

337

338`resolveSettings()` restituisce un oggetto che descrive le impostazioni unite e la fonte che ha contribuito a ogni chiave.

339

340| Proprietà | Tipo | Descrizione |

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

342| `effective` | `Settings` | Impostazioni unite dopo l'applicazione di tutte le fonti abilitate in ordine di precedenza |

343| `provenance` | `Partial<Record<keyof Settings, ProvenanceEntry>>` | Per ogni chiave di primo livello in `effective`, quale fonte ha fornito il valore |

344| `sources` | `Array<{ source, settings, path?, policyOrigin? }>` | Impostazioni grezze per fonte, ordinate dalla precedenza più bassa a quella più alta |

345

346#### Esempio

347

348L'esempio seguente risolve le impostazioni per una directory di progetto e stampa la fonte che controlla il periodo di pulizia.

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## Tipi362## Tipi

312 363

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

864 | SDKFilesPersistedEvent915 | SDKFilesPersistedEvent

865 | SDKToolUseSummaryMessage916 | SDKToolUseSummaryMessage

866 | SDKRateLimitEvent917 | SDKRateLimitEvent

918 | SDKPermissionDeniedMessage

867 | SDKPromptSuggestionMessage;919 | SDKPromptSuggestionMessage;

868```920```

869 921

1052};1104};

1053```1105```

1054 1106

1107### `SDKPermissionDeniedMessage`

1108

1109Evento di flusso emesso quando il sistema di autorizzazione nega automaticamente una chiamata di tool senza un prompt interattivo. Usalo per rendere il rifiuto nella tua interfaccia utente mentre accade, piuttosto che osservare solo il risultato del tool `is_error` che segue. Il percorso della richiesta interattiva raggiunge la tua applicazione separatamente tramite il callback [`canUseTool`](#canusetool). I rifiuti emessi da un hook `PreToolUse` non vengono segnalati tramite questo evento.

1110

1111Questo evento richiede Claude Code v2.1.136 o successivo.

1112

1113```typescript theme={null}

1114type SDKPermissionDeniedMessage = {

1115 type: "system";

1116 subtype: "permission_denied";

1117 tool_name: string;

1118 tool_use_id: string;

1119 agent_id?: string;

1120 decision_reason_type?: string;

1121 decision_reason?: string;

1122 message: string;

1123 uuid: UUID;

1124 session_id: string;

1125};

1126```

1127

1128| Campo | Tipo | Descrizione |

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

1130| `tool_name` | `string` | Nome del tool che è stato negato |

1131| `tool_use_id` | `string` | ID del blocco `tool_use` a cui questo rifiuto risponde |

1132| `agent_id` | `string` | ID del subagente quando la chiamata negata ha avuto origine all'interno di un subagente. Rispecchia il campo su `can_use_tool` per l'instradamento lato host |

1133| `decision_reason_type` | `string` | Discriminatore per il componente che ha deciso, come `"rule"`, `"mode"`, `"classifier"`, o `"asyncAgent"` |

1134| `decision_reason` | `string` | Motivo leggibile dall'uomo dal componente che ha deciso, quando disponibile |

1135| `message` | `string` | Messaggio di rifiuto restituito al modello nel `tool_result` |

1136

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

1056 1138

1057Informazioni su un uso di tool negato.1139Informazioni su un uso di tool negato.

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# Gestire approvazioni e input dell'utente

7> Presenta le richieste di approvazione e le domande di chiarimento di Claude agli utenti, quindi restituisci le loro decisioni all'SDK.

9Durante il lavoro su un'attività, Claude a volte ha bisogno di verificare con gli utenti. Potrebbe aver bisogno di autorizzazione prima di eliminare file, oppure potrebbe aver bisogno di chiedere quale database utilizzare per un nuovo progetto. La tua applicazione deve presentare queste richieste agli utenti in modo che Claude possa continuare con il loro input.

11Claude richiede input dell'utente in due situazioni: quando ha bisogno di **autorizzazione per utilizzare uno strumento** (come eliminare file o eseguire comandi), e quando ha **domande di chiarimento** (tramite lo strumento `AskUserQuestion`). Entrambi attivano il tuo callback `canUseTool`, che mette in pausa l'esecuzione fino a quando non restituisci una risposta. Questo è diverso dai normali turni di conversazione in cui Claude finisce e attende il tuo prossimo messaggio.

13Per le domande di chiarimento, Claude genera le domande e le opzioni. Il tuo ruolo è presentarle agli utenti e restituire le loro selezioni. Non puoi aggiungere le tue domande a questo flusso; se hai bisogno di chiedere qualcosa agli utenti tu stesso, fallo separatamente nella logica dell'applicazione.

15Il callback può rimanere in sospeso indefinitamente. L'esecuzione rimane in pausa fino a quando il callback non restituisce, e l'SDK annulla l'attesa solo quando la query stessa viene annullata. Se un utente potrebbe impiegare più tempo per rispondere di quanto il tuo processo possa ragionevolmente rimanere in esecuzione, l'SDK TypeScript supporta il [hook `defer` decision](/it/hooks#defer-a-tool-call-for-later), che consente al processo di uscire e riprendere in seguito dalla sessione persistente; questa opzione non è disponibile nell'SDK Python.

17Questa guida ti mostra come rilevare ogni tipo di richiesta e rispondere in modo appropriato.

19## Rilevare quando Claude ha bisogno di input

21Passa un callback `canUseTool` nelle opzioni della query. Il callback si attiva ogni volta che Claude ha bisogno di input dell'utente, ricevendo il nome dello strumento e l'input come argomenti:

23<CodeGroup>

24 ```python Python theme={null}

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

26 # Chiedi all'utente e restituisci allow o 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 // Chiedi all'utente e restituisci allow o deny

37 }

39 const options = { canUseTool: handleToolRequest };

40 ```

41</CodeGroup>

43Il callback si attiva in due casi:

451. **Lo strumento ha bisogno di approvazione**: Claude vuole utilizzare uno strumento che non è approvato automaticamente dalle [regole di autorizzazione](/it/agent-sdk/permissions) o dalle modalità. Controlla `tool_name` per lo strumento (ad es. `"Bash"`, `"Write"`).

462. **Claude pone una domanda**: Claude chiama lo strumento `AskUserQuestion`. Controlla se `tool_name == "AskUserQuestion"` per gestirlo diversamente. Se specifichi un array `tools`, includi `AskUserQuestion` affinché funzioni. Vedi [Gestire domande di chiarimento](#handle-clarifying-questions) per i dettagli.

48<Note>

49 Per consentire o negare automaticamente gli strumenti senza chiedere agli utenti, utilizza invece gli [hook](/it/agent-sdk/hooks). Gli hook vengono eseguiti prima di `canUseTool` e possono consentire, negare o modificare le richieste in base alla tua logica. Puoi anche utilizzare l'[hook `PermissionRequest`](/it/agent-sdk/hooks#available-hooks) per inviare notifiche esterne (Slack, email, push) quando Claude è in attesa di approvazione.

50</Note>

52## Gestire le richieste di approvazione dello strumento

54Una volta passato un callback `canUseTool` nelle opzioni della query, si attiva quando Claude vuole utilizzare uno strumento che non è approvato automaticamente. Il tuo callback riceve tre argomenti:

56| Argomento | Descrizione |

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

58| `toolName` | Il nome dello strumento che Claude vuole utilizzare (ad es. `"Bash"`, `"Write"`, `"Edit"`) |

59| `input` | I parametri che Claude sta passando allo strumento. Il contenuto varia a seconda dello strumento. |

60| `options` (TS) / `context` (Python) | Contesto aggiuntivo incluso `suggestions` opzionale (voci `PermissionUpdate` proposte per evitare di ripetere le domande) e un segnale di annullamento. In TypeScript, `signal` è un `AbortSignal`; in Python, il campo signal è riservato per uso futuro. Vedi [`ToolPermissionContext`](/it/agent-sdk/python#toolpermissioncontext) per Python. |

62L'oggetto `input` contiene parametri specifici dello strumento. Esempi comuni:

64| Strumento | Campi di input |

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

71Vedi il riferimento SDK per gli schemi di input completi: [Python](/it/agent-sdk/python#tool-input%2Foutput-types) | [TypeScript](/it/agent-sdk/typescript#tool-input-types).

73Puoi visualizzare queste informazioni all'utente in modo che possa decidere se consentire o rifiutare l'azione, quindi restituire la risposta appropriata.

75L'esempio seguente chiede a Claude di creare ed eliminare un file di test. Quando Claude tenta ogni operazione, il callback stampa la richiesta dello strumento nel terminale e chiede l'approvazione s/n.

77<CodeGroup>

78 ```python Python theme={null}

79 import asyncio

81 from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query

82 from claude_agent_sdk.types import (

83 HookMatcher,

84 PermissionResultAllow,

85 PermissionResultDeny,

86 ToolPermissionContext,

87 )

90 async def can_use_tool(

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

92 ) -> PermissionResultAllow | PermissionResultDeny:

93 # Visualizza la richiesta dello strumento

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 # Ottieni l'approvazione dell'utente

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

104

105 # Restituisci allow o deny in base alla risposta dell'utente

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

107 # Allow: lo strumento viene eseguito con l'input originale (o modificato)

108 return PermissionResultAllow(updated_input=input_data)

109 else:

110 # Deny: lo strumento non viene eseguito, Claude vede il messaggio

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

112

113

114 # Workaround richiesto: dummy hook mantiene il flusso aperto per 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 per chiedere all'utente l'input nel terminale

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 // Visualizza la richiesta dello strumento

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 // Ottieni l'approvazione dell'utente

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

177

178 // Restituisci allow o deny in base alla risposta dell'utente

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

180 // Allow: lo strumento viene eseguito con l'input originale (o modificato)

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

182 } else {

183 // Deny: lo strumento non viene eseguito, Claude vede il messaggio

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 In Python, `can_use_tool` richiede la [modalità streaming](/it/agent-sdk/streaming-vs-single-mode) e un hook `PreToolUse` che restituisce `{"continue_": True}` per mantenere il flusso aperto. Senza questo hook, il flusso si chiude prima che il callback di autorizzazione possa essere invocato.

196</Note>

197

198Questo esempio utilizza un flusso s/n in cui qualsiasi input diverso da `y` viene trattato come un rifiuto. In pratica, potresti creare un'interfaccia utente più ricca che consenta agli utenti di modificare la richiesta, fornire feedback o reindirizzare completamente Claude. Vedi [Rispondere alle richieste dello strumento](#respond-to-tool-requests) per tutti i modi in cui puoi rispondere.

199

200### Rispondere alle richieste dello strumento

201

202Il tuo callback restituisce uno di due tipi di risposta:

203

204| Risposta | Python | TypeScript |

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

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

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

208

209Quando consenti, passa l'input dello strumento (originale o modificato). Quando neghi, fornisci un messaggio che spiega il motivo. Claude vede questo messaggio e potrebbe adattare il suo approccio.

210

211<CodeGroup>

212 ```python Python theme={null}

213 from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

214

215 # Consenti l'esecuzione dello strumento

216 return PermissionResultAllow(updated_input=input_data)

217

218 # Blocca lo strumento

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

220 ```

221

222 ```typescript TypeScript theme={null}

223 // Consenti l'esecuzione dello strumento

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

225

226 // Blocca lo strumento

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

228 ```

229</CodeGroup>

230

231Oltre a consentire o negare, puoi modificare l'input dello strumento o fornire contesto che aiuta Claude ad adattare il suo approccio:

232

233* **Approva**: consenti l'esecuzione dello strumento come richiesto da Claude

234* **Approva con modifiche**: modifica l'input prima dell'esecuzione (ad es. sanitizza i percorsi, aggiungi vincoli)

235* **Rifiuta**: blocca lo strumento e spiega a Claude il motivo

236* **Suggerisci alternativa**: blocca ma guida Claude verso ciò che l'utente vuole invece

237* **Reindirizza completamente**: utilizza [input streaming](/it/agent-sdk/streaming-vs-single-mode) per inviare a Claude un'istruzione completamente nuova

238

239<Tabs>

240 <Tab title="Approva">

241 L'utente approva l'azione così com'è. Passa l'`input` dal tuo callback invariato e lo strumento viene eseguito esattamente come richiesto da Claude.

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="Approva con modifiche">

269 L'utente approva ma vuole modificare la richiesta prima. Puoi cambiare l'input prima che lo strumento venga eseguito. Claude vede il risultato ma non gli viene detto che hai cambiato qualcosa. Utile per sanitizzare i parametri, aggiungere vincoli o limitare l'accesso.

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'utente ha approvato, ma limita tutti i comandi alla 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'utente ha approvato, ma limita tutti i comandi alla 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="Rifiuta">

301 L'utente non vuole che questa azione accada. Blocca lo strumento e fornisci un messaggio che spiega il motivo. Claude vede questo messaggio e potrebbe provare un approccio diverso.

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="Suggerisci alternativa">

330 L'utente non vuole questa azione specifica, ma ha un'idea diversa. Blocca lo strumento e includi una guida nel tuo messaggio. Claude leggerà questo e deciderà come procedere in base al tuo feedback.

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'utente non vuole eliminare, suggerisci di comprimere invece

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'utente non vuole eliminare, suggerisci di comprimere invece

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="Reindirizza completamente">

360 Per un cambio di direzione completo (non solo una spinta), utilizza [input streaming](/it/agent-sdk/streaming-vs-single-mode) per inviare a Claude una nuova istruzione direttamente. Questo bypassa la richiesta dello strumento corrente e dà a Claude istruzioni completamente nuove da seguire.

361 </Tab>

362</Tabs>

363

364## Gestire domande di chiarimento

365

366Quando Claude ha bisogno di più direzione su un'attività con più approcci validi, chiama lo strumento `AskUserQuestion`. Questo attiva il tuo callback `canUseTool` con `toolName` impostato su `AskUserQuestion`. L'input contiene le domande di Claude come opzioni a scelta multipla, che visualizzi all'utente e restituisci le sue selezioni.

367

368<Tip>

369 Le domande di chiarimento sono particolarmente comuni nella [modalità `plan`](/it/agent-sdk/permissions#plan-mode-plan), dove Claude esplora la base di codice e pone domande prima di proporre un piano. Questo rende la modalità plan ideale per flussi di lavoro interattivi in cui vuoi che Claude raccolga i requisiti prima di apportare modifiche.

370</Tip>

371

372I seguenti passaggi mostrano come gestire le domande di chiarimento:

373

374<Steps>

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

376 Passa un callback `canUseTool` nelle opzioni della query. Per impostazione predefinita, `AskUserQuestion` è disponibile. Se specifichi un array `tools` per limitare le capacità di Claude (ad esempio, un agente di sola lettura con solo `Read`, `Glob` e `Grep`), includi `AskUserQuestion` in quell'array. Altrimenti, Claude non sarà in grado di porre domande di chiarimento:

377

378 <CodeGroup>

379 ```python Python theme={null}

380 async for message in query(

381 prompt="Analyze this codebase",

382 options=ClaudeAgentOptions(

383 # Includi AskUserQuestion nella tua lista di strumenti

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 // Includi AskUserQuestion nella tua lista di strumenti

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

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

398 // Gestisci le domande di chiarimento qui

399 }

400 }

401 })) {

402 console.log(message);

403 }

404 ```

405 </CodeGroup>

406 </Step>

407

408 <Step title="Rileva AskUserQuestion">

409 Nel tuo callback, controlla se `toolName` è uguale a `AskUserQuestion` per gestirlo diversamente da altri strumenti:

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 # La tua implementazione per raccogliere risposte dall'utente

416 return await handle_clarifying_questions(input_data)

417 # Gestisci altri strumenti normalmente

418 return await prompt_for_approval(tool_name, input_data)

419 ```

420

421 ```typescript TypeScript theme={null}

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

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

424 // La tua implementazione per raccogliere risposte dall'utente

425 return handleClarifyingQuestions(input);

426 }

427 // Gestisci altri strumenti normalmente

428 return promptForApproval(toolName, input);

429 };

430 ```

431 </CodeGroup>

432 </Step>

433

434 <Step title="Analizza l'input della domanda">

435 L'input contiene le domande di Claude in un array `questions`. Ogni domanda ha una `question` (il testo da visualizzare), `options` (le scelte) e `multiSelect` (se sono consentite più selezioni):

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 Vedi [Formato della domanda](#question-format) per le descrizioni complete dei campi.

463 </Step>

464

465 <Step title="Raccogli risposte dall'utente">

466 Presenta le domande all'utente e raccogli le sue selezioni. Come lo fai dipende dalla tua applicazione: un prompt del terminale, un modulo web, una finestra di dialogo mobile, ecc.

467 </Step>

468

469 <Step title="Restituisci le risposte a Claude">

470 Costruisci l'oggetto `answers` come un record in cui ogni chiave è il testo `question` e ogni valore è l'`label` dell'opzione selezionata:

471

472 | Dall'oggetto domanda | Usa come |

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

474 | Campo `question` (ad es. `"How should I format the output?"`) | Chiave |

475 | Campo `label` dell'opzione selezionata (ad es. `"Summary"`) | Valore |

476

477 Per le domande a selezione multipla, passa un array di etichette o uniscile con `", "`. Se [supporti input di testo libero](#support-free-text-input), utilizza il testo personalizzato dell'utente come valore.

478

479 <CodeGroup>

480 ```python Python theme={null}

481 return PermissionResultAllow(

482 updated_input={

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

484 "answers": {

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

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

487 },

488 }

489 )

490 ```

491

492 ```typescript TypeScript theme={null}

493 return {

494 behavior: "allow",

495 updatedInput: {

496 questions: input.questions,

497 answers: {

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

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

500 }

501 }

502 };

503 ```

504 </CodeGroup>

505 </Step>

506</Steps>

507

508### Formato della domanda

509

510L'input contiene le domande generate da Claude in un array `questions`. Ogni domanda ha questi campi:

511

512| Campo | Descrizione |

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

514| `question` | Il testo completo della domanda da visualizzare |

515| `header` | Etichetta breve per la domanda (max 12 caratteri) |

516| `options` | Array di 2-4 scelte, ognuna con `label` e `description`. TypeScript: opzionalmente `preview` (vedi [sotto](#option-previews-type-script)) |

517| `multiSelect` | Se `true`, gli utenti possono selezionare più opzioni |

518

519La struttura che il tuo callback riceve:

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#### Anteprime delle opzioni (TypeScript)

538

539`toolConfig.askUserQuestion.previewFormat` aggiunge un campo `preview` a ogni opzione in modo che la tua app possa mostrare un mockup visivo insieme all'etichetta. Senza questa impostazione, Claude non genera anteprime e il campo è assente.

540

541| `previewFormat` | `preview` contiene |

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

543| non impostato (predefinito) | Il campo è assente. Claude non genera anteprime. |

544| `"markdown"` | ASCII art e blocchi di codice recintati |

545| `"html"` | Un frammento `<div>` stilizzato (l'SDK rifiuta `<script>`, `<style>` e `<!DOCTYPE>` prima che il tuo callback venga eseguito) |

546

547Il formato si applica a tutte le domande nella sessione. Claude include `preview` sulle opzioni in cui un confronto visivo aiuta (scelte di layout, schemi di colori) e lo omette dove non lo farebbe (conferme sì/no, scelte solo testo). Controlla `undefined` prima di eseguire il rendering.

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 è una stringa HTML o undefined

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

561 }

562 }

563})) {

564 // ...

565}

566```

567

568Un'opzione con un'anteprima HTML:

569

570```json theme={null}

571{

572 "label": "Compact",

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

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

575}

576```

577

578### Formato della risposta

579

580Restituisci un oggetto `answers` che mappa il campo `question` di ogni domanda all'`label` dell'opzione selezionata:

581

582| Campo | Descrizione |

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

584| `questions` | Passa l'array di domande originale (obbligatorio per l'elaborazione dello strumento) |

585| `answers` | Oggetto in cui le chiavi sono il testo della domanda e i valori sono le etichette selezionate |

586

587Per le domande a selezione multipla, passa un array di etichette o uniscile con `", "`. Per l'input di testo libero, utilizza il testo personalizzato dell'utente direttamente.

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#### Supporta input di testo libero

602

603Le opzioni predefinite di Claude non copriranno sempre ciò che gli utenti vogliono. Per consentire agli utenti di digitare la propria risposta:

604

605* Visualizza una scelta "Other" aggiuntiva dopo le opzioni di Claude che accetta input di testo

606* Utilizza il testo personalizzato dell'utente come valore della risposta (non la parola "Other")

607

608Vedi l'[esempio completo](#complete-example) di seguito per un'implementazione completa.

609

610### Esempio completo

611

612Claude pone domande di chiarimento quando ha bisogno di input dell'utente per procedere. Ad esempio, quando gli viene chiesto di aiutare a decidere su uno stack tecnologico per un'app mobile, Claude potrebbe chiedere informazioni su cross-platform vs nativo, preferenze di backend o piattaforme di destinazione. Queste domande aiutano Claude a prendere decisioni che corrispondono alle preferenze dell'utente piuttosto che indovinare.

613

614Questo esempio gestisce quelle domande in un'applicazione terminale. Ecco cosa accade ad ogni passaggio:

615

6161. **Instrada la richiesta**: Il callback `canUseTool` controlla se il nome dello strumento è `"AskUserQuestion"` e instrada a un gestore dedicato

6172. **Visualizza le domande**: Il gestore scorre l'array `questions` e stampa ogni domanda con opzioni numerate

6183. **Raccogli input**: L'utente può inserire un numero per selezionare un'opzione, o digitare testo libero direttamente (ad es. "jquery", "i don't know")

6194. **Mappa le risposte**: Il codice controlla se l'input è numerico (utilizza l'etichetta dell'opzione) o testo libero (utilizza il testo direttamente)

6205. **Restituisci a Claude**: La risposta include sia l'array `questions` originale che la mappatura `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 """Analizza l'input dell'utente come numero(i) di opzione o testo libero."""

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 """Visualizza le domande di Claude e raccogli le risposte dell'utente."""

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 # Instrada AskUserQuestion al nostro gestore di domande

670 if tool_name == "AskUserQuestion":

671 return await handle_ask_user_question(input_data)

672 # Auto-approva altri strumenti per questo esempio

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 # Workaround richiesto: dummy hook mantiene il flusso aperto per 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 per chiedere all'utente l'input nel terminale

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 // Analizza l'input dell'utente come numero(i) di opzione o testo libero

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 // Visualizza le domande di Claude e raccogli le risposte dell'utente

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 // Restituisci le risposte a Claude (deve includere le domande originali)

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 // Instrada AskUserQuestion al nostro gestore di domande

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

762 return handleAskUserQuestion(input);

763 }

764 // Auto-approva altri strumenti per questo esempio

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

778

779* **Subagenti**: `AskUserQuestion` non è attualmente disponibile nei subagenti generati tramite lo strumento Agent

780* **Limiti delle domande**: ogni chiamata `AskUserQuestion` supporta 1-4 domande con 2-4 opzioni ciascuna

781

782## Altri modi per ottenere input dall'utente

783

784Il callback `canUseTool` e lo strumento `AskUserQuestion` coprono la maggior parte degli scenari di approvazione e chiarimento, ma l'SDK offre altri modi per ottenere input dagli utenti:

785

786### Input streaming

787

788Utilizza [input streaming](/it/agent-sdk/streaming-vs-single-mode) quando hai bisogno di:

789

790* **Interrompere l'agente a metà attività**: invia un segnale di annullamento o cambia direzione mentre Claude sta lavorando

791* **Fornire contesto aggiuntivo**: aggiungi informazioni di cui Claude ha bisogno senza aspettare che le chieda

792* **Costruire interfacce di chat**: consenti agli utenti di inviare messaggi di follow-up durante operazioni di lunga durata

793

794L'input streaming è ideale per interfacce conversazionali in cui gli utenti interagiscono con l'agente durante l'esecuzione, non solo nei checkpoint di approvazione.

795

796### Strumenti personalizzati

797

798Utilizza [strumenti personalizzati](/it/agent-sdk/custom-tools) quando hai bisogno di:

799

800* **Raccogliere input strutturato**: costruisci moduli, procedure guidate o flussi di lavoro multi-step che vanno oltre il formato a scelta multipla di `AskUserQuestion`

801* **Integrare sistemi di approvazione esterni**: connettiti a piattaforme di ticketing, flusso di lavoro o approvazione esistenti

802* **Implementare interazioni specifiche del dominio**: crea strumenti personalizzati per le esigenze della tua applicazione, come interfacce di revisione del codice o elenchi di controllo di distribuzione

803

804Gli strumenti personalizzati ti danno il controllo completo sull'interazione, ma richiedono più lavoro di implementazione rispetto all'utilizzo del callback `canUseTool` integrato.

805

806## Risorse correlate

807

808* [Configura autorizzazioni](/it/agent-sdk/permissions): configura modalità e regole di autorizzazione

809* [Controlla l'esecuzione con hook](/it/agent-sdk/hooks): esegui codice personalizzato nei punti chiave del ciclo di vita dell'agente

810* [Riferimento SDK TypeScript](/it/agent-sdk/typescript#canusetool): documentazione API completa di canUseTool

auto-mode-config.md +17 −12

Details

24* [Ispezionare la tua configurazione effettiva](#inspect-the-defaults-and-your-effective-config) con i sottocomandi `claude auto-mode`24* [Ispezionare la tua configurazione effettiva](#inspect-the-defaults-and-your-effective-config) con i sottocomandi `claude auto-mode`

25* [Esaminare i rifiuti](#review-denials) in modo da sapere cosa aggiungere successivamente25* [Esaminare i rifiuti](#review-denials) in modo da sapere cosa aggiungere successivamente

26 26

~~27## Where the classifier reads configuration~~27## Dove il classificatore legge la configurazione

28 28

29Il classificatore legge lo stesso contenuto [CLAUDE.md](/it/memory) che Claude stesso carica, quindi un'istruzione come "non forzare mai il push" nel CLAUDE.md del tuo progetto guida sia Claude che il classificatore contemporaneamente. Inizia da lì per le convenzioni del progetto e le regole comportamentali.29Il classificatore legge lo stesso contenuto [CLAUDE.md](/it/memory) che Claude stesso carica, quindi un'istruzione come "non forzare mai il push" nel CLAUDE.md del tuo progetto guida sia Claude che il classificatore contemporaneamente. Inizia da lì per le convenzioni del progetto e le regole comportamentali.

30 30

39 39

40Il classificatore non legge `autoMode` dalle impostazioni di progetto condivise in `.claude/settings.json`, quindi un repository archiviato non può iniettare le proprie regole di autorizzazione.40Il classificatore non legge `autoMode` dalle impostazioni di progetto condivise in `.claude/settings.json`, quindi un repository archiviato non può iniettare le proprie regole di autorizzazione.

41 41

42Le voci di ogni ambito vengono combinate. Uno sviluppatore può estendere `environment`, `allow` e `soft_deny` con voci personali ma non può rimuovere le voci fornite dalle impostazioni gestite. Poiché le regole di autorizzazione agiscono come eccezioni alle regole di blocco all'interno del classificatore, una voce `allow` aggiunta da uno sviluppatore può sostituire una voce `soft_deny` dell'organizzazione: la combinazione è additiva, non un confine di politica rigida.42Le voci di ogni ambito vengono combinate. Uno sviluppatore può estendere `environment`, `allow`, `soft_deny` e `hard_deny` con voci personali ma non può rimuovere le voci fornite dalle impostazioni gestite. Poiché le regole di autorizzazione agiscono come eccezioni alle regole di blocco morbido all'interno del classificatore, una voce `allow` aggiunta da uno sviluppatore può sostituire una voce `soft_deny` dell'organizzazione: la combinazione è additiva, non un confine di politica rigida.

43 43

44<Note>44<Note>

45 Il classificatore è una seconda porta che si esegue dopo il [sistema di autorizzazioni](/it/permissions). Per le azioni che non devono mai essere eseguite indipendentemente dall'intento dell'utente o dalla configurazione del classificatore, utilizza `permissions.deny` nelle impostazioni gestite, che blocca l'azione prima che il classificatore venga consultato e non può essere ignorato.45 Il classificatore è una seconda porta che si esegue dopo il [sistema di autorizzazioni](/it/permissions). Per le azioni che non devono mai essere eseguite indipendentemente dall'intento dell'utente o dalla configurazione del classificatore, utilizza `permissions.deny` nelle impostazioni gestite, che blocca l'azione prima che il classificatore venga consultato e non può essere ignorato.

99 99

100## Sostituisci le regole di blocco e autorizzazione100## Sostituisci le regole di blocco e autorizzazione

101 101

102Due campi aggiuntivi ti permettono di sostituire gli elenchi di regole incorporati del classificatore: `autoMode.soft_deny` controlla cosa viene bloccato e `autoMode.allow` controlla quali eccezioni si applicano. Ognuno è un array di descrizioni in prosa, lette come regole in linguaggio naturale. Non esiste un campo `autoMode.deny`; per bloccare duramente un'azione indipendentemente dall'intento, utilizza [`permissions.deny`](/it/permissions), che viene eseguito prima del classificatore.102Tre campi aggiuntivi ti permettono di sostituire gli elenchi di regole incorporati del classificatore: `autoMode.hard_deny` per i confini di sicurezza incondizionati, `autoMode.soft_deny` per le azioni distruttive che l'intento dell'utente può annullare, e `autoMode.allow` per le eccezioni. Ognuno è un array di descrizioni in prosa, lette come regole in linguaggio naturale. Per i blocchi duri basati su pattern di strumenti che vengono eseguiti prima del classificatore, utilizza [`permissions.deny`](/it/permissions).

103 103

104All'interno del classificatore, la precedenza funziona in tre livelli:104All'interno del classificatore, la precedenza funziona in quattro livelli:

105 105

106* Le regole `soft_deny` bloccano per prime106* Le regole `hard_deny` bloccano incondizionatamente. L'intento dell'utente e le eccezioni `allow` non si applicano.

107* Le regole `allow` quindi sostituiscono i blocchi corrispondenti come eccezioni107* Le regole `soft_deny` bloccano successivamente. L'intento dell'utente e le eccezioni `allow` possono ignorare questi blocchi.

108* L'intento esplicito dell'utente sostituisce entrambi: se il messaggio dell'utente descrive direttamente e specificamente l'azione esatta che Claude sta per intraprendere, il classificatore la consente anche quando una regola `soft_deny` corrisponde108* Le regole `allow` quindi sostituiscono i blocchi `soft_deny` corrispondenti come eccezioni.

109* L'intento esplicito dell'utente ignora i blocchi soft rimanenti: se il messaggio dell'utente descrive direttamente e specificamente l'azione esatta che Claude sta per intraprendere, il classificatore la consente anche quando una regola `soft_deny` corrisponde.

109 110

110Le richieste generali non contano come intento esplicito. Chiedere a Claude di "pulire il repository" non autorizza il force-push, ma chiedere a Claude di "force-push questo ramo" sì.111Le richieste generali non contano come intento esplicito. Chiedere a Claude di "pulire il repository" non autorizza il force-push, ma chiedere a Claude di "force-push questo ramo" sì.

111 112

112Per allentare, aggiungi a `allow` quando il classificatore contrassegna ripetutamente un pattern di routine che le eccezioni predefinite non coprono. Per stringere, aggiungi a `soft_deny` per i rischi specifici del tuo ambiente che i valori predefiniti non coprono. Per mantenere le regole incorporate mentre aggiungi le tue, includi la stringa letterale `"$defaults"` nell'array. Le regole predefinite vengono inserite in quella posizione, quindi le tue regole personalizzate possono andare prima o dopo di esse, e continui a ereditare gli aggiornamenti mentre l'elenco incorporato cambia tra le versioni.113Per allentare, aggiungi a `allow` quando il classificatore contrassegna ripetutamente un pattern di routine che le eccezioni predefinite non coprono. Per stringere, aggiungi a `soft_deny` per i rischi distruttivi specifici del tuo ambiente che i valori predefiniti non coprono, o a `hard_deny` per i confini di sicurezza che non devono mai essere superati. Per mantenere le regole incorporate mentre aggiungi le tue, includi la stringa letterale `"$defaults"` nell'array. Le regole predefinite vengono inserite in quella posizione, quindi le tue regole personalizzate possono andare prima o dopo di esse, e continui a ereditare gli aggiornamenti mentre l'elenco incorporato cambia tra le versioni.

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 L'impostazione di uno qualsiasi di `environment`, `allow` o `soft_deny` senza `"$defaults"` sostituisce l'intero elenco predefinito per quella sezione. Se imposti `soft_deny` con una singola voce e ometti `"$defaults"`, ogni regola di blocco incorporata viene scartata: force push, esfiltrazione di dati, `curl | bash`, distribuzioni di produzione e tutte le altre regole di blocco predefinite diventano consentite. Ometti `"$defaults"` solo quando intendi assumere la piena proprietà dell'elenco. In tal caso, esegui `claude auto-mode defaults` per stampare le regole incorporate, copiale nel tuo file di impostazioni, quindi esamina ogni regola rispetto alla tua pipeline e tolleranza al rischio.141 L'impostazione di uno qualsiasi di `environment`, `allow`, `soft_deny` o `hard_deny` senza `"$defaults"` sostituisce l'intero elenco predefinito per quella sezione. Un array `soft_deny` senza `"$defaults"` scarta ogni regola di blocco soft incorporata, inclusi force push, `curl | bash` e distribuzioni di produzione. Un array `hard_deny` senza `"$defaults"` scarta le regole incorporate di esfiltrazione dei dati e di bypass dei controlli di sicurezza.

137</Danger>142</Danger>

138 143

139Ogni sezione viene valutata indipendentemente, quindi l'impostazione di `environment` da sola lascia intatti gli elenchi predefiniti `allow` e `soft_deny`.144Ogni sezione viene valutata indipendentemente, quindi l'impostazione di `environment` da sola lascia intatti gli elenchi predefiniti `allow`, `soft_deny` e `hard_deny`. Ometti `"$defaults"` solo quando intendi assumere la piena proprietà dell'elenco. Per farlo in modo sicuro, esegui `claude auto-mode defaults` per stampare le regole incorporate, copiale nel tuo file di impostazioni, quindi esamina ogni regola rispetto alla tua pipeline e tolleranza al rischio.

140 145

141## Ispeziona i valori predefiniti e la tua configurazione effettiva146## Ispeziona i valori predefiniti e la tua configurazione effettiva

142 147

143Tre sottocomandi CLI ti aiutano a ispezionare e convalidare la tua configurazione.148Tre sottocomandi CLI ti aiutano a ispezionare e convalidare la tua configurazione.

144 149

145Stampa le regole `environment`, `allow` e `soft_deny` incorporate come JSON:150Stampa le regole `environment`, `allow`, `soft_deny` e `hard_deny` incorporate come 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

157Ottieni feedback AI sulle tue regole `allow` e `soft_deny` personalizzate:162Ottieni feedback AI sulle tue regole `allow`, `soft_deny` e `hard_deny` personalizzate:

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>` | Fai una rapida [domanda laterale](/it/interactive-mode#side-questions-with-%2Fbtw) senza aggiungerla alla conversazione |46| `/btw <question>` | Fai una rapida [domanda laterale](/it/interactive-mode#side-questions-with-%2Fbtw) senza aggiungerla alla conversazione |

48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/it/skills#bundled-skills).** Carica il materiale di riferimento dell'API Claude per il linguaggio del tuo progetto (Python, TypeScript, Java, Go, Ruby, C#, PHP o cURL) e il riferimento degli Agenti Gestiti. Copre l'uso degli strumenti, lo streaming, i batch, gli output strutturati e le insidie comuni. Si attiva anche automaticamente quando il tuo codice importa `anthropic` o `@anthropic-ai/sdk`. Esegui `/claude-api migrate` per aggiornare il codice dell'API Claude esistente a un modello più recente: Claude chiede quali file scansionare e quale modello scegliere come destinazione, quindi aggiorna gli ID del modello, la configurazione del thinking e altri parametri che sono cambiati tra le versioni. Esegui `/claude-api managed-agents-onboard` per una procedura guidata interattiva che crea un nuovo Agente Gestito da zero |48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/it/skills#bundled-skills).** Carica il materiale di riferimento dell'API Claude per il linguaggio del tuo progetto (Python, TypeScript, Java, Go, Ruby, C#, PHP o cURL) e il riferimento degli Agenti Gestiti. Copre l'uso degli strumenti, lo streaming, i batch, gli output strutturati e le insidie comuni. Si attiva anche automaticamente quando il tuo codice importa `anthropic` o `@anthropic-ai/sdk`. Esegui `/claude-api migrate` per aggiornare il codice dell'API Claude esistente a un modello più recente: Claude chiede quali file scansionare e quale modello scegliere come destinazione, quindi aggiorna gli ID del modello, la configurazione del thinking e altri parametri che sono cambiati tra le versioni. Esegui `/claude-api managed-agents-onboard` per una procedura guidata interattiva che crea un nuovo Agente Gestito da zero |

49| `/clear` | Avvia una nuova conversazione con contesto vuoto. La conversazione precedente rimane disponibile in `/resume`. Per liberare il contesto continuando la stessa conversazione, usa `/compact` invece. Alias: `/reset`, `/new` |49| `/clear [name]` | Avvia una nuova conversazione con contesto vuoto. La conversazione precedente rimane disponibile in `/resume`. Passa un nome per etichettare la conversazione precedente nel selettore `/resume`. Per liberare il contesto continuando la stessa conversazione, usa `/compact` invece. Alias: `/reset`, `/new` |

50| `/color [color\|default]` | Imposta il colore della barra dei prompt per la sessione corrente. Colori disponibili: `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Usa `default` per ripristinare, oppure esegui senza argomento per scegliere un colore casuale. Quando [Remote Control](/it/remote-control) è connesso, il colore si sincronizza con claude.ai/code |50| `/color [color\|default]` | Imposta il colore della barra dei prompt per la sessione corrente. Colori disponibili: `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Usa `default` per ripristinare, oppure esegui senza argomento per scegliere un colore casuale. Quando [Remote Control](/it/remote-control) è connesso, il colore si sincronizza con claude.ai/code |

51| `/compact [instructions]` | Libera il contesto riassumendo la conversazione finora. Facoltativamente passa istruzioni di focus per il riassunto. Vedi [come la compattazione gestisce regole, skill e file di memoria](/it/context-window#what-survives-compaction) |51| `/compact [instructions]` | Libera il contesto riassumendo la conversazione finora. Facoltativamente passa istruzioni di focus per il riassunto. Vedi [come la compattazione gestisce regole, skill e file di memoria](/it/context-window#what-survives-compaction) |

52| `/config` | Apri l'interfaccia [Impostazioni](/it/settings) per regolare il tema, il modello, lo [stile di output](/it/output-styles) e altre preferenze. Alias: `/settings` |52| `/config` | Apri l'interfaccia [Impostazioni](/it/settings) per regolare il tema, il modello, lo [stile di output](/it/output-styles) e altre preferenze. Alias: `/settings` |

53| `/context` | Visualizza l'utilizzo del contesto corrente come una griglia colorata. Mostra suggerimenti di ottimizzazione per gli strumenti pesanti di contesto, gonfiore della memoria e avvisi di capacità |53| `/context [all]` | Visualizza l'utilizzo del contesto corrente come una griglia colorata. Mostra suggerimenti di ottimizzazione per gli strumenti pesanti di contesto, gonfiore della memoria e avvisi di capacità. In [modalità a schermo intero](/it/fullscreen) la ripartizione per elemento è compressa per mantenere la griglia visibile. Passa `all` per espanderla |

54| `/copy [N]` | Copia l'ultima risposta dell'assistente negli appunti. Passa un numero `N` per copiare la N-esima risposta più recente: `/copy 2` copia la penultima. Quando sono presenti blocchi di codice, mostra un selettore interattivo per selezionare singoli blocchi o la risposta completa. Premi `w` nel selettore per scrivere la selezione in un file invece che negli appunti, il che è utile tramite SSH |54| `/copy [N]` | Copia l'ultima risposta dell'assistente negli appunti. Passa un numero `N` per copiare la N-esima risposta più recente: `/copy 2` copia la penultima. Quando sono presenti blocchi di codice, mostra un selettore interattivo per selezionare singoli blocchi o la risposta completa. Premi `w` nel selettore per scrivere la selezione in un file invece che negli appunti, il che è utile tramite SSH |

56| `/debug [description]` | **[Skill](/it/skills#bundled-skills).** Abilita la registrazione del debug per la sessione corrente e risolvi i problemi leggendo il log di debug della sessione. La registrazione del debug è disattivata per impostazione predefinita a meno che tu non abbia avviato con `claude --debug`, quindi eseguire `/debug` a metà sessione inizia a catturare i log da quel momento in poi. Facoltativamente descrivi il problema per focalizzare l'analisi |56| `/debug [description]` | **[Skill](/it/skills#bundled-skills).** Abilita la registrazione del debug per la sessione corrente e risolvi i problemi leggendo il log di debug della sessione. La registrazione del debug è disattivata per impostazione predefinita a meno che tu non abbia avviato con `claude --debug`, quindi eseguire `/debug` a metà sessione inizia a catturare i log da quel momento in poi. Facoltativamente descrivi il problema per focalizzare l'analisi |

89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Rimosso in v2.1.91. Chiedi direttamente a Claude di visualizzare i commenti della pull request. Nelle versioni precedenti, recupera e visualizza i commenti da una pull request di GitHub; rileva automaticamente il PR per il ramo corrente, oppure passa un URL o un numero di PR. Richiede la CLI `gh` |89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Rimosso in v2.1.91. Chiedi direttamente a Claude di visualizzare i commenti della pull request. Nelle versioni precedenti, recupera e visualizza i commenti da una pull request di GitHub; rileva automaticamente il PR per il ramo corrente, oppure passa un URL o un numero di PR. Richiede la CLI `gh` |

90| `/privacy-settings` | Visualizza e aggiorna le tue impostazioni di privacy. Disponibile solo per gli abbonati ai piani Pro e Max |90| `/privacy-settings` | Visualizza e aggiorna le tue impostazioni di privacy. Disponibile solo per gli abbonati ai piani Pro e Max |

91| `/radio` | Apri Claude FM lo-fi radio nel tuo browser. Stampa l'URL dello stream quando nessun browser è disponibile. Non disponibile su Bedrock, Vertex o Foundry |

91| `/recap` | Genera un riassunto di una riga della sessione corrente su richiesta. Vedi [Recap della sessione](/it/interactive-mode#session-recap) per il recap automatico che appare dopo che sei stato assente |92| `/recap` | Genera un riassunto di una riga della sessione corrente su richiesta. Vedi [Recap della sessione](/it/interactive-mode#session-recap) per il recap automatico che appare dopo che sei stato assente |

92| `/release-notes` | Visualizza il changelog in un selettore di versione interattivo. Seleziona una versione specifica per visualizzare le sue note di rilascio, o scegli di mostrare tutte le versioni |93| `/release-notes` | Visualizza il changelog in un selettore di versione interattivo. Seleziona una versione specifica per visualizzare le sue note di rilascio, o scegli di mostrare tutte le versioni |

93| `/reload-plugins` | Ricarica tutti i [plugins](/it/plugins) attivi per applicare le modifiche in sospeso senza riavviare. Segnala i conteggi per ogni componente ricaricato e contrassegna eventuali errori di caricamento |94| `/reload-plugins` | Ricarica tutti i [plugins](/it/plugins) attivi per applicare le modifiche in sospeso senza riavviare. Segnala i conteggi per ogni componente ricaricato e contrassegna eventuali errori di caricamento |

env-vars.md +2 −0

Details

116| `CLAUDE_CODE_MAX_RETRIES` | Sovrascrivi il numero di volte per riprovare le richieste API non riuscite (predefinito: 10) |116| `CLAUDE_CODE_MAX_RETRIES` | Sovrascrivi il numero di volte per riprovare le richieste API non riuscite (predefinito: 10) |

117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Numero massimo di strumenti di sola lettura e subagent che possono essere eseguiti in parallelo (predefinito: 10). Valori più alti aumentano il parallelismo ma consumano più risorse |117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Numero massimo di strumenti di sola lettura e subagent che possono essere eseguiti in parallelo (predefinito: 10). Valori più alti aumentano il parallelismo ma consumano più risorse |

118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Imposta su `1` per generare server MCP stdio con solo un ambiente di base sicuro più il `env` configurato del server, invece di ereditare l'ambiente della tua shell |118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Imposta su `1` per generare server MCP stdio con solo un ambiente di base sicuro più il `env` configurato del server, invece di ereditare l'ambiente della tua shell |

119| `CLAUDE_CODE_NATIVE_CURSOR` | Imposta su `1` per mostrare il cursore proprio del terminale al cursore di input invece di un blocco disegnato. Il cursore rispetta le impostazioni di lampeggio, forma e focus del terminale |

119| `CLAUDE_CODE_NEW_INIT` | Imposta su `1` per fare in modo che `/init` esegua un flusso di configurazione interattivo. Il flusso chiede quali file generare, inclusi CLAUDE.md, skill e hook, prima di esplorare la base di codice e scriverli. Senza questa variabile, `/init` genera un CLAUDE.md automaticamente senza chiedere. |120| `CLAUDE_CODE_NEW_INIT` | Imposta su `1` per fare in modo che `/init` esegua un flusso di configurazione interattivo. Il flusso chiede quali file generare, inclusi CLAUDE.md, skill e hook, prima di esplorare la base di codice e scriverli. Senza questa variabile, `/init` genera un CLAUDE.md automaticamente senza chiedere. |

120| `CLAUDE_CODE_NO_FLICKER` | Imposta su `1` per abilitare il [rendering a schermo intero](/it/fullscreen), un'anteprima di ricerca che riduce lo sfarfallio e mantiene la memoria piatta nelle conversazioni lunghe. Equivalente all'impostazione [`tui`](/it/settings#available-settings); puoi anche passare con `/tui fullscreen` |121| `CLAUDE_CODE_NO_FLICKER` | Imposta su `1` per abilitare il [rendering a schermo intero](/it/fullscreen), un'anteprima di ricerca che riduce lo sfarfallio e mantiene la memoria piatta nelle conversazioni lunghe. Equivalente all'impostazione [`tui`](/it/settings#available-settings); puoi anche passare con `/tui fullscreen` |

121| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | Token di aggiornamento OAuth per l'autenticazione Claude.ai. Se impostato, `claude auth login` scambia questo token direttamente invece di aprire un browser. Richiede `CLAUDE_CODE_OAUTH_SCOPES`. Utile per il provisioning dell'autenticazione in ambienti automatizzati |122| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | Token di aggiornamento OAuth per l'autenticazione Claude.ai. Se impostato, `claude auth login` scambia questo token direttamente invece di aprire un browser. Richiede `CLAUDE_CODE_OAUTH_SCOPES`. Utile per il provisioning dell'autenticazione in ambienti automatizzati |

191| `DISABLE_TELEMETRY` | Imposta su `1` per rinunciare alla telemetria. Gli eventi di telemetria non includono dati utente come codice, percorsi di file o comandi bash |192| `DISABLE_TELEMETRY` | Imposta su `1` per rinunciare alla telemetria. Gli eventi di telemetria non includono dati utente come codice, percorsi di file o comandi bash |

192| `DISABLE_UPDATES` | Imposta su `1` per bloccare tutti gli aggiornamenti incluso il manuale `claude update` e `claude install`. Più rigoroso di `DISABLE_AUTOUPDATER`. Utilizza quando distribuisci Claude Code attraverso i tuoi canali e gli utenti non dovrebbero auto-aggiornarsi |193| `DISABLE_UPDATES` | Imposta su `1` per bloccare tutti gli aggiornamenti incluso il manuale `claude update` e `claude install`. Più rigoroso di `DISABLE_AUTOUPDATER`. Utilizza quando distribuisci Claude Code attraverso i tuoi canali e gli utenti non dovrebbero auto-aggiornarsi |

195| `DO_NOT_TRACK` | Imposta su `1` per rinunciare alla telemetria. Equivalente all'impostazione di `DISABLE_TELEMETRY`. Onorato come la [convenzione standard tra strumenti](https://consoledonottrack.com/) |

194| `ENABLE_CLAUDEAI_MCP_SERVERS` | Imposta su `false` per disabilitare i [server MCP claude.ai](/it/mcp#use-mcp-servers-from-claude-ai) in Claude Code. Abilitato per impostazione predefinita per gli utenti connessi |196| `ENABLE_CLAUDEAI_MCP_SERVERS` | Imposta su `false` per disabilitare i [server MCP claude.ai](/it/mcp#use-mcp-servers-from-claude-ai) in Claude Code. Abilitato per impostazione predefinita per gli utenti connessi |

195| `ENABLE_PROMPT_CACHING_1H` | Imposta su `1` per richiedere un TTL della cache dei prompt di 1 ora invece dei 5 minuti predefiniti. Destinato agli utenti di chiave API, [Bedrock](/it/amazon-bedrock), [Vertex](/it/google-vertex-ai) e [Foundry](/it/microsoft-foundry). Gli utenti di abbonamento ricevono automaticamente il TTL di 1 ora. Le scritture della cache di 1 ora vengono fatturate a una tariffa più elevata |197| `ENABLE_PROMPT_CACHING_1H` | Imposta su `1` per richiedere un TTL della cache dei prompt di 1 ora invece dei 5 minuti predefiniti. Destinato agli utenti di chiave API, [Bedrock](/it/amazon-bedrock), [Vertex](/it/google-vertex-ai) e [Foundry](/it/microsoft-foundry). Gli utenti di abbonamento ricevono automaticamente il TTL di 1 ora. Le scritture della cache di 1 ora vengono fatturate a una tariffa più elevata |

errors.md +16 −0

Details

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

252* Esegui `/status` in seguito per confermare che la credenziale attiva è il tuo abbonamento253* Esegui `/status` in seguito per confermare che la credenziale attiva è il tuo abbonamento

253* Se nessuna variabile di ambiente è impostata e l'errore persiste, l'organizzazione disabilitata è quella legata al tuo `/login`. Contatta il supporto o accedi con un account diverso.254* Se nessuna variabile di ambiente è impostata e l'errore persiste, l'organizzazione disabilitata è quella legata al tuo `/login`. Contatta il supporto o accedi con un account diverso.

254 255

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

257

258L'amministratore del tuo Team o Enterprise ha disattivato le routine a livello organizzativo. L'errore appare quando tenti di creare o eseguire una routine, incluso da `/schedule` e dall'interfaccia utente [Routines](/it/routines) su claude.ai/code.

259

260```text theme={null}

261Routines are disabled by your organization's policy.

262```

263

264Questa è un'impostazione lato server, quindi non può essere sovrascritta dalle impostazioni locali, dalle variabili di ambiente o dai flag CLI.

265

266**Cosa fare:**

267

268* Chiedi al tuo amministratore di abilitare l'interruttore **Routines** su [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code)

269* Per lavori programmati una tantum che non richiedono routine a livello organizzativo, vedi [scheduled tasks](/it/scheduled-tasks)

270

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

256 272

257Il tuo accesso salvato non è più valido. Un token revocato significa che hai effettuato il logout ovunque o un amministratore ha rimosso l'accesso; un token scaduto significa che l'aggiornamento automatico non è riuscito a metà sessione.273Il tuo accesso salvato non è più valido. Un token revocato significa che hai effettuato il logout ovunque o un amministratore ha rimosso l'accesso; un token scaduto significa che l'aggiornamento automatico non è riuscito a metà sessione.

interactive-mode.md +1 −1

Details

289 289

290Dopo che Claude risponde, i suggerimenti continuano ad apparire in base alla vostra cronologia di conversazione, come un passaggio di follow-up da una richiesta in più parti o una continuazione naturale del vostro flusso di lavoro.290Dopo che Claude risponde, i suggerimenti continuano ad apparire in base alla vostra cronologia di conversazione, come un passaggio di follow-up da una richiesta in più parti o una continuazione naturale del vostro flusso di lavoro.

291 291

292* Premete **Tab** o **Freccia destra** per accettare il suggerimento, oppure premete **Enter** per accettare e inviare292* Premete **Tab** o **Freccia destra** per inserire il suggerimento nell'input del prompt, quindi **Invio** per inviare

293* Iniziate a digitare per dismissarlo293* Iniziate a digitare per dismissarlo

294 294

295Il suggerimento viene eseguito come una richiesta in background che riutilizza la cache del prompt della conversazione padre, quindi il costo aggiuntivo è minimo. Claude Code salta la generazione di suggerimenti quando la cache è fredda per evitare costi inutili.295Il suggerimento viene eseguito come una richiesta in background che riutilizza la cache del prompt della conversazione padre, quindi il costo aggiuntivo è minimo. Claude Code salta la generazione di suggerimenti quando la cache è fredda per evitare costi inutili.

mcp.md +2 −0

Details

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

266```266```

267 267

268Quando si configurano i server MCP tramite JSON in `.mcp.json`, `~/.claude.json`, o `claude mcp add-json`, il campo `type` accetta `streamable-http` come alias per `http`. La specifica MCP utilizza il nome `streamable-http` per questo trasporto, quindi le configurazioni copiate dalla documentazione del server funzionano senza modifiche.

269

268### Opzione 2: Aggiungi un server SSE remoto270### Opzione 2: Aggiungi un server SSE remoto

269 271

270<Warning>272<Warning>

permissions.md +7 −0

Details

210* `Edit(//tmp/scratch.txt)`: modifica il percorso assoluto `/tmp/scratch.txt`210* `Edit(//tmp/scratch.txt)`: modifica il percorso assoluto `/tmp/scratch.txt`

211* `Read(src/**)`: legge da `<current-directory>/src/`211* `Read(src/**)`: legge da `<current-directory>/src/`

212 212

213Una regola corrisponde solo ai file sotto il suo ancoraggio, quindi l'ancoraggio determina quanto lontano una regola deny raggiunge. I nomi di file nudi seguono la semantica gitignore e corrispondono a qualsiasi profondità, quindi `Read(.env)` e `Read(**/.env)` sono equivalenti:

214

215| Regola deny | Blocca | Non blocca |

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

217| `Read(.env)` o `Read(**/.env)` | qualsiasi `.env` alla o sotto la directory corrente | `.env` in una directory padre o in un altro progetto |

218| `Read(//**/.env)` | qualsiasi `.env` in qualsiasi punto del filesystem | nulla; la regola è ancorata alla radice del filesystem |

219

213<Note>220<Note>

214 Nei modelli gitignore, `*` corrisponde ai file in una singola directory mentre `**` corrisponde ricorsivamente tra le directory. Per consentire l'accesso a tutti i file, utilizzate solo il nome dello strumento senza parentesi: `Read`, `Edit` o `Write`.221 Nei modelli gitignore, `*` corrisponde ai file in una singola directory mentre `**` corrisponde ricorsivamente tra le directory. Per consentire l'accesso a tutti i file, utilizzate solo il nome dello strumento senza parentesi: `Read`, `Edit` o `Write`.

215</Note>222</Note>

plugins-reference.md +8 −3

Details

423 423

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

510 510

511### Regole del comportamento del percorso511### Regole del comportamento del percorso

512 512

513Per `skills`, `commands`, `agents`, `outputStyles`, `experimental.themes` e `experimental.monitors`, un percorso personalizzato sostituisce il valore predefinito. Se il manifest specifica `skills`, la directory predefinita `skills/` non viene scansionata; se specifica `experimental.monitors`, il valore predefinito `monitors/monitors.json` non viene caricato. [Hooks](#hooks), [MCP servers](#mcp-servers) e [LSP servers](#lsp-servers) hanno semantica diversa per gestire più fonti.513Se un percorso personalizzato sostituisce o estende la directory predefinita del plugin dipende dal campo:

514

515* **Sostituisce il valore predefinito**: `commands`, `agents`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Ad esempio, quando il manifest specifica `commands`, la directory predefinita `commands/` non viene scansionata. Per mantenere il valore predefinito e aggiungerne altri, elencalo esplicitamente: `"commands": ["./commands/", "./extras/"]`

516* **Aggiunge al valore predefinito**: `skills`. La directory predefinita `skills/` viene sempre scansionata e le directory elencate in `skills` vengono caricate insieme ad essa

517* **Regole di merge proprie**: [hooks](#hooks), [MCP servers](#mcp-servers) e [LSP servers](#lsp-servers). Vedi ogni sezione per come più fonti si combinano

518

519Per tutti i campi del percorso:

514 520

515* Tutti i percorsi devono essere relativi alla radice del plugin e iniziare con `./`521* Tutti i percorsi devono essere relativi alla radice del plugin e iniziare con `./`

516* I componenti dai percorsi personalizzati utilizzano le stesse regole di denominazione e spazio dei nomi522* I componenti dai percorsi personalizzati utilizzano le stesse regole di denominazione e spazio dei nomi

517* È possibile specificare più percorsi come array523* È possibile specificare più percorsi come array

518* Per mantenere la directory predefinita e aggiungere più percorsi per skills, commands, agents o output styles, includi il valore predefinito nel tuo array: `"skills": ["./skills/", "./extras/"]`

519* Quando un percorso di skill punta a una directory che contiene direttamente un `SKILL.md`, ad esempio `"skills": ["./"]` che punta alla radice del plugin, il campo frontmatter `name` in `SKILL.md` determina il nome di invocazione della skill. Questo fornisce un nome stabile indipendentemente dalla directory di installazione. Se `name` non è impostato nel frontmatter, il nome della directory viene utilizzato come fallback.524* Quando un percorso di skill punta a una directory che contiene direttamente un `SKILL.md`, ad esempio `"skills": ["./"]` che punta alla radice del plugin, il campo frontmatter `name` in `SKILL.md` determina il nome di invocazione della skill. Questo fornisce un nome stabile indipendentemente dalla directory di installazione. Se `name` non è impostato nel frontmatter, il nome della directory viene utilizzato come fallback.

520 525

521**Esempi di percorso**:526**Esempi di percorso**:

routines.md +8 −0

Details

22 22

23Le routine sono disponibili sui piani Pro, Max, Team ed Enterprise con [Claude Code sul web](/it/claude-code-on-the-web) abilitato. Creale e gestiscile su [claude.ai/code/routines](https://claude.ai/code/routines), oppure dalla CLI con `/schedule`.23Le routine sono disponibili sui piani Pro, Max, Team ed Enterprise con [Claude Code sul web](/it/claude-code-on-the-web) abilitato. Creale e gestiscile su [claude.ai/code/routines](https://claude.ai/code/routines), oppure dalla CLI con `/schedule`.

24 24

25Gli amministratori di Team ed Enterprise possono disabilitare le routine per tutti i membri con l'interruttore Routines su [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code). Quando disabilitate, le routine esistenti smettono di funzionare e i membri non possono crearne di nuove.

25Questa pagina copre la creazione di una routine, la configurazione di ogni tipo di trigger, la gestione delle esecuzioni e come si applicano i limiti di utilizzo.27Questa pagina copre la creazione di una routine, la configurazione di ogni tipo di trigger, la gestione delle esecuzioni e come si applicano i limiti di utilizzo.

26 28

27## Esempi di casi d'uso29## Esempi di casi d'uso

360 362

361Le esecuzioni una tantum non contano rispetto al limite giornaliero di esecuzioni di routine. Riducono l'utilizzo regolare dell'abbonamento come qualsiasi altra sessione, ma sono esenti dall'indennità giornaliera di esecuzioni di routine per account.363Le esecuzioni una tantum non contano rispetto al limite giornaliero di esecuzioni di routine. Riducono l'utilizzo regolare dell'abbonamento come qualsiasi altra sessione, ma sono esenti dall'indennità giornaliera di esecuzioni di routine per account.

362 364

365## Troubleshooting

366

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

368

369Il tuo amministratore di Team o Enterprise ha probabilmente disattivato l'interruttore **Routines** su [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code). Questa è un'impostazione dell'organizzazione lato server, quindi non può essere ignorata dalla tua configurazione locale. Contatta il tuo amministratore per richiedere che le routine siano abilitate per la tua organizzazione.

370

363## Risorse correlate371## Risorse correlate

364 372

365* [`/loop` e pianificazione in-sessione](/it/scheduled-tasks): pianifica attività locali all'interno di una sessione CLI aperta373* [`/loop` e pianificazione in-sessione](/it/scheduled-tasks): pianifica attività locali all'interno di una sessione CLI aperta

security.md +1 −1

Details

59* **Approvazione della richiesta di rete**: Gli strumenti che effettuano richieste di rete richiedono l'approvazione dell'utente per impostazione predefinita59* **Approvazione della richiesta di rete**: Gli strumenti che effettuano richieste di rete richiedono l'approvazione dell'utente per impostazione predefinita

60* **Finestre di contesto isolate**: Web fetch utilizza una finestra di contesto separata per evitare di iniettare prompt potenzialmente dannosi60* **Finestre di contesto isolate**: Web fetch utilizza una finestra di contesto separata per evitare di iniettare prompt potenzialmente dannosi

61* **Verifica della fiducia**: Le prime esecuzioni di codebase e i nuovi server MCP richiedono la verifica della fiducia61* **Verifica della fiducia**: Le prime esecuzioni di codebase e i nuovi server MCP richiedono la verifica della fiducia

~~62 * Nota: La verifica della fiducia è disabilitata quando si esegue in modo non interattivo con il flag `-p`~~62 * Nota: La verifica della fiducia è disabilitata quando si esegue in modo non interattivo con il flag `-p`. L'eccezione è [`--worktree`](/it/worktrees), che richiede comunque che la fiducia sia stata accettata per la directory

63* **Rilevamento dell'iniezione di comandi**: I comandi bash sospetti richiedono l'approvazione manuale anche se precedentemente allowlisted63* **Rilevamento dell'iniezione di comandi**: I comandi bash sospetti richiedono l'approvazione manuale anche se precedentemente allowlisted

64* **Corrispondenza fail-closed**: I comandi non corrispondenti richiedono per impostazione predefinita l'approvazione manuale64* **Corrispondenza fail-closed**: I comandi non corrispondenti richiedono per impostazione predefinita l'approvazione manuale

65* **Descrizioni in linguaggio naturale**: I comandi bash complessi includono spiegazioni per la comprensione dell'utente65* **Descrizioni in linguaggio naturale**: I comandi bash complessi includono spiegazioni per la comprensione dell'utente

server-managed-settings.md +3 −2

Details

41 </Step>41 </Step>

42 42

43 <Step title="Definire le impostazioni">43 <Step title="Definire le impostazioni">

44 Aggiungere la configurazione come JSON. Tutte le [impostazioni disponibili in `settings.json`](/it/settings#available-settings) sono supportate, inclusi [hooks](/it/hooks), [variabili di ambiente](/it/env-vars), e [impostazioni solo gestite](/it/permissions#managed-only-settings) come `allowManagedPermissionRulesOnly`.44 Aggiungere la configurazione come JSON. Tutte le [impostazioni disponibili in `settings.json`](/it/settings#available-settings) sono supportate eccetto quelle limitate alla distribuzione delle politiche a livello del sistema operativo; vedere [Limitazioni attuali](#current-limitations) per questo breve elenco. Questo include [hooks](/it/hooks), [variabili di ambiente](/it/env-vars), e [impostazioni solo gestite](/it/permissions#managed-only-settings) come `allowManagedPermissionRulesOnly`.

45 45

46 Questo esempio applica un elenco di negazione delle autorizzazioni, impedisce agli utenti di ignorare le autorizzazioni e limita le regole di autorizzazione a quelle definite nelle impostazioni gestite:46 Questo esempio applica un elenco di negazione delle autorizzazioni, impedisce agli utenti di ignorare le autorizzazioni e limita le regole di autorizzazione a quelle definite nelle impostazioni gestite:

47 47

93 }93 }

94 ```94 ```

95 95

96 Poiché gli hook eseguono comandi shell, gli utenti vedono una [finestra di dialogo di approvazione della sicurezza](#security-approval-dialogs) prima che vengano applicati. Vedere [Configurare la modalità auto](/it/auto-mode-config) per come le voci `autoMode` influenzano ciò che il classificatore blocca e avvertimenti importanti sui campi `allow` e `soft_deny`.96 Poiché gli hook eseguono comandi shell, gli utenti vedono una [finestra di dialogo di approvazione della sicurezza](#security-approval-dialogs) prima che vengano applicati. Vedere [Configurare la modalità auto](/it/auto-mode-config) per come le voci `autoMode` influenzano ciò che il classificatore blocca e avvertimenti importanti sui campi `environment`, `allow`, `soft_deny` e `hard_deny`.

97 </Step>97 </Step>

98 98

99 <Step title="Salvare e distribuire">99 <Step title="Salvare e distribuire">

124 124

125* Le impostazioni si applicano uniformemente a tutti gli utenti dell'organizzazione. Le configurazioni per gruppo non sono ancora supportate.125* Le impostazioni si applicano uniformemente a tutti gli utenti dell'organizzazione. Le configurazioni per gruppo non sono ancora supportate.

126* Le [configurazioni del server MCP](/it/mcp#managed-mcp-configuration) non possono essere distribuite tramite impostazioni gestite dal server.126* Le [configurazioni del server MCP](/it/mcp#managed-mcp-configuration) non possono essere distribuite tramite impostazioni gestite dal server.

127* Le impostazioni limitate alle fonti delle politiche a livello del sistema operativo, come `policyHelper` e `wslInheritsWindowsSettings`, non vengono rispettate. Distribuirle invece tramite MDM o un file `managed-settings.json` di sistema.

127 128

128## Consegna delle impostazioni129## Consegna delle impostazioni

129 130

settings.md +29 −2

Details

169| `attribution` | Personalizza l'attribuzione per i commit git e le pull request. Vedi [Impostazioni di attribuzione](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |169| `attribution` | Personalizza l'attribuzione per i commit git e le pull request. Vedi [Impostazioni di attribuzione](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |

170| `autoMemoryDirectory` | Directory personalizzata per l'archiviazione della [memoria automatica](/it/memory#storage-location). Accetta un percorso assoluto o un percorso con prefisso `~/`. Accettato dalle impostazioni di politica e utente, e dal flag `--settings`. Non accettato dalle impostazioni di progetto o locale, poiché un repository clonato potrebbe fornire uno dei due file per reindirizzare le scritture di memoria a posizioni sensibili | `"~/my-memory-dir"` |170| `autoMemoryDirectory` | Directory personalizzata per l'archiviazione della [memoria automatica](/it/memory#storage-location). Accetta un percorso assoluto o un percorso con prefisso `~/`. Accettato dalle impostazioni di politica e utente, e dal flag `--settings`. Non accettato dalle impostazioni di progetto o locale, poiché un repository clonato potrebbe fornire uno dei due file per reindirizzare le scritture di memoria a posizioni sensibili | `"~/my-memory-dir"` |

171| `autoMemoryEnabled` | Abilita la [memoria automatica](/it/memory#enable-or-disable-auto-memory). Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Predefinito: `true`. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/it/env-vars) in `env` | `false` |171| `autoMemoryEnabled` | Abilita la [memoria automatica](/it/memory#enable-or-disable-auto-memory). Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Predefinito: `true`. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/it/env-vars) in `env` | `false` |

172| `autoMode` | Personalizza cosa il classificatore della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode) blocca e consente. Contiene array `environment`, `allow` e `soft_deny` di regole in prosa. Includi la stringa letterale `"$defaults"` in un array per ereditare le regole incorporate in quella posizione. Vedi [Configura la modalità auto](/it/auto-mode-config). Non letto dalle impostazioni di progetto condivise | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |172| `autoMode` | Personalizza cosa il classificatore della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode) blocca e consente. Contiene array `environment`, `allow`, `soft_deny` e `hard_deny` di regole in prosa. Includi la stringa letterale `"$defaults"` in un array per ereditare le regole incorporate in quella posizione. Vedi [Configura la modalità auto](/it/auto-mode-config). Non letto dalle impostazioni di progetto condivise | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |

173| `autoScrollEnabled` | Nel [rendering fullscreen](/it/fullscreen), segui il nuovo output fino al fondo della conversazione. Predefinito: `true`. Appare in `/config` come **Auto-scroll**. I prompt di permesso scorrono comunque in vista quando questo è disattivato | `false` |173| `autoScrollEnabled` | Nel [rendering fullscreen](/it/fullscreen), segui il nuovo output fino al fondo della conversazione. Predefinito: `true`. Appare in `/config` come **Auto-scroll**. I prompt di permesso scorrono comunque in vista quando questo è disattivato | `false` |

174| `autoUpdatesChannel` | Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` (predefinito) per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta [`DISABLE_AUTOUPDATER`](/it/setup#disable-auto-updates) in `env` | `"stable"` |174| `autoUpdatesChannel` | Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` (predefinito) per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta [`DISABLE_AUTOUPDATER`](/it/setup#disable-auto-updates) in `env` | `"stable"` |

175| `availableModels` | Limita quali modelli gli utenti possono selezionare tramite `/model`, `--model`, o `ANTHROPIC_MODEL`. Non influisce sull'opzione Predefinito. Vedi [Limita la selezione del modello](/it/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |175| `availableModels` | Limita quali modelli gli utenti possono selezionare tramite `/model`, `--model`, o `ANTHROPIC_MODEL`. Non influisce sull'opzione Predefinito. Vedi [Limita la selezione del modello](/it/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |

202| `forceRemoteSettingsRefresh` | (Solo impostazioni gestite) Blocca l'avvio della CLI fino a quando le impostazioni gestite remote non vengono recuperate di recente dal server. Se il recupero fallisce, la CLI esce invece di continuare con le impostazioni memorizzate nella cache o senza impostazioni. Quando non impostato, l'avvio continua senza attendere le impostazioni remote. Vedi [applicazione fail-closed](/it/server-managed-settings#enforce-fail-closed-startup) | `true` |202| `forceRemoteSettingsRefresh` | (Solo impostazioni gestite) Blocca l'avvio della CLI fino a quando le impostazioni gestite remote non vengono recuperate di recente dal server. Se il recupero fallisce, la CLI esce invece di continuare con le impostazioni memorizzate nella cache o senza impostazioni. Quando non impostato, l'avvio continua senza attendere le impostazioni remote. Vedi [applicazione fail-closed](/it/server-managed-settings#enforce-fail-closed-startup) | `true` |

203| `gcpAuthRefresh` | Script personalizzato che aggiorna le credenziali predefinite dell'applicazione GCP quando scadono o non possono essere caricate. Vedi [configurazione avanzata delle credenziali](/it/google-vertex-ai#advanced-credential-configuration) | `gcloud auth application-default login` |203| `gcpAuthRefresh` | Script personalizzato che aggiorna le credenziali predefinite dell'applicazione GCP quando scadono o non possono essere caricate. Vedi [configurazione avanzata delle credenziali](/it/google-vertex-ai#advanced-credential-configuration) | `gcloud auth application-default login` |

204| `hooks` | Configura comandi personalizzati da eseguire agli eventi del ciclo di vita. Vedi [documentazione hooks](/it/hooks) per il formato | Vedi [hooks](/it/hooks) |204| `hooks` | Configura comandi personalizzati da eseguire agli eventi del ciclo di vita. Vedi [documentazione hooks](/it/hooks) per il formato | Vedi [hooks](/it/hooks) |

205| `httpHookAllowedEnvVars` | Elenco di autorizzazione dei nomi delle variabili di ambiente che gli hook HTTP possono interpolare nelle intestazioni. Quando impostato, l'`allowedEnvVars` effettivo di ogni hook è l'intersezione con questo elenco. Non definito = nessuna restrizione. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |205| `httpHookAllowedEnvVars` | Elenco di autorizzazione dei nomi delle variabili di ambiente che gli hook HTTP possono interpolare nelle intestazioni. Quando impostato, l'`allowedEnvVars` effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione. Non definito = nessuna restrizione. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |

206| `includeCoAuthoredBy` | **Deprecato**: Usa `attribution` invece. Se includere la riga `co-authored-by Claude` nei commit git e nelle pull request (predefinito: `true`) | `false` |206| `includeCoAuthoredBy` | **Deprecato**: Usa `attribution` invece. Se includere la riga `co-authored-by Claude` nei commit git e nelle pull request (predefinito: `true`) | `false` |

207| `includeGitInstructions` | Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude (predefinito: `true`). Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata | `false` |207| `includeGitInstructions` | Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude (predefinito: `true`). Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata | `false` |

208| `language` | Configura la lingua di risposta preferita di Claude (ad es., `"japanese"`, `"spanish"`, `"french"`). Claude risponderà in questa lingua per impostazione predefinita. Imposta anche la lingua della [dettatura vocale](/it/voice-dictation#change-the-dictation-language) | `"japanese"` |208| `language` | Configura la lingua di risposta preferita di Claude (ad es., `"japanese"`, `"spanish"`, `"french"`). Claude risponderà in questa lingua per impostazione predefinita. Imposta anche la lingua della [dettatura vocale](/it/voice-dictation#change-the-dictation-language) | `"japanese"` |

216| `plansDirectory` | Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans` | `"./plans"` |216| `plansDirectory` | Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans` | `"./plans"` |

217| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |

218| `policyHelper` | {/* min-version: 2.1.136 */}Eseguibile distribuito dall'amministratore che calcola le impostazioni gestite dinamicamente all'avvio. Onorato solo da MDM o da un file `managed-settings.json` di sistema. Vedi [Calcola le impostazioni gestite con un policy helper](#compute-managed-settings-with-a-policy-helper). Richiede Claude Code v2.1.136 o successivo | `{"path": "/usr/local/bin/claude-policy"}` |

218| `preferredNotifChannel` | Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predefinito: `"auto"`, che invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come **Notifications**. Vedi [Ottieni un campanello del terminale o una notifica](/it/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |219| `preferredNotifChannel` | Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predefinito: `"auto"`, che invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come **Notifications**. Vedi [Ottieni un campanello del terminale o una notifica](/it/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |

220| `prUrlTemplate` | Modello di URL per il badge PR mostrato nel footer e nei riassunti dei risultati degli strumenti. Sostituisce `{host}`, `{owner}`, `{repo}`, `{number}`, e `{url}` dall'URL PR segnalato da `gh`. Usa per puntare i link PR a uno strumento di revisione del codice interno invece di `github.com`. Non influisce sui link automatici `#123` nella prosa di Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |221| `prUrlTemplate` | Modello di URL per il badge PR mostrato nel footer e nei riassunti dei risultati degli strumenti. Sostituisce `{host}`, `{owner}`, `{repo}`, `{number}`, e `{url}` dall'URL PR segnalato da `gh`. Usa per puntare i link PR a uno strumento di revisione del codice interno invece di `github.com`. Non influisce sui link automatici `#123` nella prosa di Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |

470}471}

471```472```

472 473

474### Calcola le impostazioni gestite con un policy helper

475

476L'impostazione `policyHelper` punta a un eseguibile che calcola le impostazioni gestite all'avvio, in modo che gli amministratori possano derivare la politica dalla postura del dispositivo, dall'identità o da un servizio remoto invece di un file statico. Configuralo da MDM o da un file `managed-settings.json` di sistema. Claude Code ignora `policyHelper` quando appare in qualsiasi altro ambito, incluse le impostazioni utente, le impostazioni di progetto, l'hive di registro HKCU e le [impostazioni gestite dal server](/it/server-managed-settings).

477

478L'impostazione accetta queste chiavi:

479

480| Chiave | Tipo | Descrizione |

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

482| `path` | string | Percorso assoluto all'eseguibile helper |

483| `timeoutMs` | number | Quanto tempo attendere l'helper prima di trattare l'esecuzione come non riuscita |

484| `refreshIntervalMs` | number | Con quale frequenza ri-eseguire l'helper in background. Imposta a `0` per disabilitare l'aggiornamento, o a almeno `60000` |

485

486L'helper scrive un envelope JSON a stdout. Metti le impostazioni sotto una chiave `managedSettings` piuttosto che al livello superiore, poiché un oggetto di impostazioni nudo analizza con `managedSettings` non definito e non applica nulla:

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

498Quando l'helper emette `managedSettings`, quell'oggetto sostituisce le impostazioni gestite basate su file per l'esecuzione. Quando l'helper esce con codice non zero all'avvio, Claude Code stampa l'errore e rifiuta di avviarsi, quindi un helper che ha bisogno di resilienza di interruzione dovrebbe servire dalla sua cache e uscire con `0`.

499

473### Precedenza delle impostazioni500### Precedenza delle impostazioni

474 501

475Le impostazioni si applicano in ordine di precedenza. Dal più alto al più basso:502Le impostazioni si applicano in ordine di precedenza. Dal più alto al più basso:

whats-new.md +17 −1

Details

8 8

9Il digest settimanale per sviluppatori evidenzia le funzionalità più probabili a cambiare il modo in cui lavorate. Ogni voce include codice eseguibile, una breve demo e un collegamento alla documentazione completa. Per ogni correzione di bug e miglioramento minore, consultate il [changelog](/it/changelog).9Il digest settimanale per sviluppatori evidenzia le funzionalità più probabili a cambiare il modo in cui lavorate. Ogni voce include codice eseguibile, una breve demo e un collegamento alla documentazione completa. Per ogni correzione di bug e miglioramento minore, consultate il [changelog](/it/changelog).

10 10

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

12 **I plugin si caricano da archivi `.zip` e URL**: `--plugin-dir` ora accetta file `.zip`, e `--plugin-url` recupera un archivio plugin per la sessione corrente.

14 Anche questa settimana: **`worktree.baseRef`** sceglie se i nuovi worktree si diramano dal default remoto o dal `HEAD` locale; **regole di hard deny in auto mode** bloccano le azioni incondizionatamente indipendentemente dalle eccezioni di autorizzazione; e **i hook vedono il livello di sforzo attivo** tramite `effort.level` e `$CLAUDE_EFFORT`.

16 [Leggi il digest della Week 19 →](/it/whats-new/2026-w19)

17</Update>

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

20 **Windows senza Git Bash**: Git per Windows non è più richiesto, e Claude Code utilizza PowerShell come strumento shell quando Bash è assente.

22 Anche questa settimana: **`claude ultrareview`** porta la revisione del codice cloud a CI e script; **`claude project purge`** pulisce lo stato locale per un progetto; e incollare un **URL PR in `/resume`** trova la sessione che l'ha creato.

24 [Leggi il digest della Week 18 →](/it/whats-new/2026-w18)

25</Update>

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

12 **`/ultrareview`** si apre come anteprima di ricerca pubblica: una flotta di agenti cacciatori di bug viene eseguita nel cloud e i risultati tornano automaticamente nel vostro CLI o Desktop.28 **`/ultrareview`** si apre come anteprima di ricerca pubblica: una flotta di agenti cacciatori di bug viene eseguita nel cloud e i risultati tornano automaticamente nel vostro CLI o Desktop.

13 29

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

20 **Claude Opus 4.7** arriva come nuovo predefinito su Max e Team Premium, con un nuovo livello di sforzo `xhigh` che è l'impostazione consigliata per la maggior parte del lavoro di codifica e uno slider interattivo `/effort` per regolarlo.36 **Claude Opus 4.7** arriva come nuovo predefinito su Max e Team Premium, con un nuovo livello di sforzo `xhigh` che è l'impostazione consigliata per la maggior parte del lavoro di codifica e uno slider interattivo `/effort` per regolarlo.

21 37

22 Anche questa settimana: **Routines** su Claude Code sul web attivano agenti cloud templati da una pianificazione, un evento GitHub o una chiamata API; `/ultrareview` esegue la revisione del codice multi-agente parallela nel cloud; `/usage` mostra cosa sta guidando i vostri limiti; e il CLI si sposta su binari nativi.38 Anche questa settimana: **Routines** su Claude Code sul web attivano agenti cloud templati da una pianificazione, un evento GitHub o una chiamata API; **notifiche push mobile** vi avvisano sul telefono quando un'attività lunga termina o Claude ha bisogno di voi; `/usage` mostra cosa sta guidando i vostri limiti; e il CLI si sposta su binari nativi.

23 39

24 [Leggi il digest della Week 16 →](/it/whats-new/2026-w16)40 [Leggi il digest della Week 16 →](/it/whats-new/2026-w16)

25</Update>41</Update>

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

Details

4 4

5# Settimana 16 · 13–17 aprile 20265# Settimana 16 · 13–17 aprile 2026

6 6

7> Claude Opus 4.7 con il nuovo livello di sforzo xhigh, Routines su Claude Code sul web, /ultrareview revisione del codice cloud, un breakdown di /usage che mostra cosa sta guidando i vostri limiti, e binari nativi che sostituiscono il JavaScript raggruppato.7> Claude Opus 4.7 con il nuovo livello di sforzo xhigh, Routines su Claude Code sul web, notifiche push mobili che avvisano il vostro telefono quando Claude ha bisogno di voi, un breakdown di /usage che mostra cosa sta guidando i vostri limiti, e binari nativi che sostituiscono il JavaScript raggruppato.

8 8

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

10 <span>Releases <a href="/docs/it/changelog#2-1-105">v2.1.105 → v2.1.113</a></span>10 <span>Releases <a href="/docs/it/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">Notifiche push mobili</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">Revisione completa del codice nel cloud. Ultrareview espande il vostro branch su più revisori paralleli su Claude Code sul web, esegue un passaggio di critica avversariale su ogni risultato e restituisce un rapporto di risultati verificati mentre il vostro terminale rimane libero. Richiamatelo senza argomenti per rivedere il vostro branch attuale, o passate un numero di PR per recuperare e rivedere quella PR. La finestra di dialogo di avvio ora mostra un diffstat così sapete cosa sta salendo prima di confermare.</p>80 <p className="digest-feature-lede">Con <a href="/docs/it/remote-control">Remote Control</a> connesso, Claude può inviare una notifica push al vostro telefono quando un compito lungo si conclude o ha bisogno di una decisione per continuare. Attivatelo con "Push when Claude decides" in <code>/config</code>, o chiedete una notifica nel vostro prompt. Utile quando avviate un'esecuzione di agente lunga e volete allontanarvi dal terminale.</p>

81 81

~~82 <p className="digest-feature-try">Rivedete il branch su cui siete:</p>~~82 <Frame>

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

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

~~85 > /ultrareview~~

~~86 ```~~

87 85

~~88 <p className="digest-feature-try">O puntate a una PR:</p>~~86 <p className="digest-feature-try">Chiedete a Claude di avvisarvi quando ha finito:</p>

89 87

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

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

92 ```90 ```

93 91

~~94 <a className="digest-feature-link" href="/docs/it/ultrareview">Guida a Ultrareview</a>~~92 <a className="digest-feature-link" href="/docs/it/remote-control#mobile-push-notifications">Remote Control: notifiche push mobili</a>

95</div>93</div>

96 94

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

116 <p className="digest-wins-title">Altri vantaggi</p>114 <p className="digest-wins-title">Altri vantaggi</p>

117 115

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

117 <div>Nuovo <a href="/docs/it/ultrareview"><code>/ultrareview</code></a>: revisione completa del codice nel cloud utilizzando analisi multi-agente parallela e un passaggio di critica avversariale. Eseguitelo senza argomenti per rivedere il vostro branch attuale, o <code>/ultrareview \<PR#></code> per una PR specifica</div>

119 <div><a href="/docs/it/permission-modes#eliminate-prompts-with-auto-mode">Auto mode</a> è ora disponibile per gli abbonati Max su Opus 4.7, e il flag <code>--enable-auto-mode</code> non è più richiesto</div>118 <div><a href="/docs/it/permission-modes#eliminate-prompts-with-auto-mode">Auto mode</a> è ora disponibile per gli abbonati Max su Opus 4.7, e il flag <code>--enable-auto-mode</code> non è più richiesto</div>

120 <div><a href="/docs/it/interactive-mode#session-recap">Session recap</a> mostra un riepilogo di una riga di cosa è successo mentre eravate via; eseguite <code>/recap</code> su richiesta o disattivatelo da <code>/config</code></div>119 <div><a href="/docs/it/interactive-mode#session-recap">Session recap</a> mostra un riepilogo di una riga di cosa è successo mentre eravate via; eseguite <code>/recap</code> su richiesta o disattivatelo da <code>/config</code></div>

121 <div>Nuovo comando <code>/tui</code> e impostazione <code>tui</code> per passare tra il rendering classico e senza sfarfallio a metà conversazione; la visualizzazione focus è stata spostata da <code>Ctrl+O</code> al suo comando <code>/focus</code> dedicato</div>120 <div>Nuovo comando <code>/tui</code> e impostazione <code>tui</code> per passare tra il rendering classico e senza sfarfallio a metà conversazione; la visualizzazione focus è stata spostata da <code>Ctrl+O</code> al suo comando <code>/focus</code> dedicato</div>

122 <div>Strumento di notifica push: con <a href="/docs/it/remote-control">Remote Control</a> connesso e "Push when Claude decides" abilitato, Claude può avvisare il vostro telefono quando ha bisogno di voi</div>

123 <div>I plugin possono spedire osservatori in background tramite una chiave manifest di primo livello <code>monitors</code> che si arma automaticamente all'avvio della sessione o all'invocazione della skill</div>121 <div>I plugin possono spedire osservatori in background tramite una chiave manifest di primo livello <code>monitors</code> che si arma automaticamente all'avvio della sessione o all'invocazione della skill</div>

124 <div>Opzione "Auto (match terminal)" in <code>/theme</code> segue la modalità scura/chiara del vostro terminale</div>122 <div>Opzione "Auto (match terminal)" in <code>/theme</code> segue la modalità scura/chiara del vostro terminale</div>

125 <div><code>/fewer-permission-prompts</code> scansiona i vostri trascritti per le comuni chiamate Bash e MCP di sola lettura e propone un allowlist per <code>.claude/settings.json</code></div>123 <div><code>/fewer-permission-prompts</code> scansiona i vostri trascritti per le comuni chiamate Bash e MCP di sola lettura e propone un allowlist per <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# Settimana 18 · 27 aprile – 1 maggio 2026

7> Claude Code su Windows funziona senza Git Bash, claude auth login accetta un codice OAuth incollato quando il callback del browser non può raggiungere localhost, claude project purge pulisce lo stato locale per progetto, e incollare un URL di PR in /resume trova la sessione che l'ha creata.

9<div className="digest-meta">

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

11 <span>4 funzionalità · 27 aprile – 1 maggio</span>

12</div>

14<div className="digest-feature">

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

16 <span className="digest-feature-title">Accedi senza callback del browser</span>

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

18 </div>

20 <p className="digest-feature-lede"><code>claude auth login</code> ora accetta il codice OAuth incollato direttamente nel terminale quando il callback del browser non può raggiungere localhost. Questo copre WSL2, sessioni SSH e container, dove il reindirizzamento a una porta locale non funziona. La stessa versione corregge anche i timeout di accesso su connessioni lente o proxy e in devcontainer solo IPv6.</p>

22 <p className="digest-feature-try">Accedi, quindi incolla il codice dal browser:</p>

24 ```bash theme={null}

25 claude auth login

26 ```

28 <a className="digest-feature-link" href="/it/docs/cli-reference#cli-commands">Riferimento 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">Elimina tutto lo stato di Claude Code per un progetto: trascrizioni, attività, cronologia dei file e la voce di configurazione del progetto. Supporta `--dry-run` per visualizzare un'anteprima, `-y`/`--yes` per saltare la conferma, `-i`/`--interactive` per scegliere e `--all` per cancellare ogni progetto.</p>

39 <p className="digest-feature-try">Visualizza un'anteprima di ciò che verrebbe rimosso:</p>

41 ```bash theme={null}

42 claude project purge --dry-run

43 ```

45 <p className="digest-feature-try">Quindi eseguilo davvero:</p>

47 ```bash theme={null}

48 claude project purge

49 ```

51 <a className="digest-feature-link" href="/it/docs/cli-reference">Riferimento CLI</a>

52</div>

54<div className="digest-feature">

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

56 <span className="digest-feature-title">Riprendi per URL di PR</span>

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

58 </div>

60 <p className="digest-feature-lede">Quando crei una pull request con <code>gh pr create</code>, Claude Code la collega alla sessione che l'ha prodotta. Ora puoi tornare a quella sessione dal solo URL della PR, senza ricordare il suo nome.</p>

62 <p className="digest-feature-try">Apri il selettore di sessione:</p>

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

65 > /resume

66 ```

68 <p className="digest-feature-try">Incolla l'URL della PR nel selettore. Il primo carattere dell'incolla ti mette in modalità ricerca e l'elenco si filtra alla sessione che ha creato quella PR. Premi Invio per riprenderla. Gli URL di pull request e merge request di GitHub, GitHub Enterprise, GitLab e Bitbucket funzionano tutti.</p>

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

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

72 ```

74 <p className="digest-feature-try">Per saltare il selettore, passa invece il numero della PR sulla riga di comando:</p>

76 ```bash theme={null}

77 claude --from-pr 1234

78 ```

80 <a className="digest-feature-link" href="/it/docs/sessions#use-the-session-picker">Sessioni: usa il selettore di sessione</a>

81</div>

83<div className="digest-feature">

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

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

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

87 </div>

89 <p className="digest-feature-lede">Git per Windows non è più richiesto. Quando Bash è assente, Claude Code utilizza PowerShell come strumento shell, e quando lo strumento PowerShell è abilitato viene trattato come shell primaria. PowerShell 7 installato tramite Microsoft Store, MSI senza PATH o come strumento globale `.NET` viene ora rilevato automaticamente.</p>

91 <a className="digest-feature-link" href="/it/docs/setup">Guida di configurazione</a>

92</div>

94<div className="digest-wins">

95 <p className="digest-wins-title">Altri vantaggi</p>

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

98 <div>I server MCP possono rinunciare al differimento della ricerca degli strumenti con <code>alwaysLoad: true</code> nella loro configurazione in modo che tutti gli strumenti di quel server siano sempre disponibili</div>

99 <div>Nuovo <code>claude plugin prune</code> rimuove le dipendenze dei plugin auto-installati orfane e <code>plugin uninstall --prune</code> a cascata</div>

100 <div><code>/skills</code> ora ha una casella di ricerca di filtro per digitazione in modo da poter trovare un'abilità in un lungo elenco senza scorrere</div>

101 <div>Gli hook <code>PostToolUse</code> possono sostituire l'output dello strumento per qualsiasi strumento tramite <code>hookSpecificOutput.updatedToolOutput</code>, non solo per gli strumenti MCP</div>

102 <div>Nuovo sottocomando <a href="/it/docs/ultrareview"><code>claude ultrareview</code></a> esegue <code>/ultrareview</code> in modo non interattivo da CI o script: stampa i risultati su stdout (<code>--json</code> per output grezzo) ed esce con 0 al completamento o 1 in caso di errore</div>

103 <div><code>--dangerously-skip-permissions</code> ora ignora i prompt per le scritture in <code>.claude/</code>, <code>.git/</code>, <code>.vscode/</code>, file di configurazione della shell e altri percorsi precedentemente protetti, mentre i comandi di rimozione catastrofici continuano a richiedere conferma come rete di sicurezza</div>

104 <div>Il selettore <code>/model</code> può elencare i modelli dall'endpoint <code>/v1/models</code> del tuo gateway quando <code>ANTHROPIC\_BASE\_URL</code> punta a un gateway compatibile con Anthropic; attiva con <code>CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1</code> da v2.1.129</div>

105 <div>I server MCP che riscontrano un errore transitorio durante l'avvio ora ritentano automaticamente fino a 3 volte invece di rimanere disconnessi</div>

106 <div><code>ANTHROPIC\_BEDROCK\_SERVICE\_TIER</code> seleziona un livello di servizio Bedrock: <code>default</code>, <code>flex</code> o <code>priority</code></div>

107 <div><code>/terminal-setup</code> abilita l'impostazione di accesso agli appunti di iTerm2 in modo che <code>/copy</code> funzioni, anche da tmux</div>

108 <div>Vertex AI ora supporta la Federazione dell'Identità del Carico di Lavoro basata su certificati X.509 (mTLS ADC)</div>

109 <div>Correzioni significative delle perdite di memoria: sessioni ricche di immagini, <code>/usage</code> su cronologie di trascrizioni di grandi dimensioni e strumenti a lunga esecuzione senza eventi di progresso</div>

110 </div>

111</div>

112

113[Changelog completo per v2.1.120–v2.1.126 →](/it/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# Settimana 19 · 4–8 maggio 2026

7> Carica i plugin da archivi .zip e URL, cerca la cronologia dei comandi in tutti i progetti con Ctrl+R, crea nuovi worktrees dal HEAD locale o dal ramo predefinito remoto, e blocca le azioni in modo incondizionato con le regole di hard deny in modalità auto.

9<div className="digest-meta">

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

11 <span>2 funzionalità · 4–8 maggio</span>

12</div>

14<div className="digest-feature">

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

16 <span className="digest-feature-title">Plugin da archivi .zip e URL</span>

17 </div>

19 <p className="digest-feature-lede">`--plugin-dir` ora accetta un archivio plugin <code>.zip</code> oltre a una directory, e il nuovo flag `--plugin-url` recupera un archivio plugin da un URL per la sessione corrente. Utile per provare un plugin prima di aggiungerlo a un marketplace, o per distribuire plugin interni da un artifact store.</p>

21 <p className="digest-feature-try">Carica un plugin direttamente da un 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="/it/plugins">Guida ai plugin</a>

28</div>

30<div className="digest-feature">

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

32 <span className="digest-feature-title">Ricerca nella cronologia in tutti i tuoi progetti</span>

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

34 </div>

36 <p className="digest-feature-lede"><code>Ctrl+R</code> la ricerca inversa ora predefinisce tutti i prompt in tutti i progetti, ripristinando il comportamento precedente a v2.1.124. Premi <code>Ctrl+S</code> durante la ricerca per restringere al progetto o alla sessione corrente. Utile quando ricordi un comando che hai eseguito in un altro repository la settimana scorsa e non vuoi andare a cercarlo.</p>

38 <a className="digest-feature-link" href="/it/interactive-mode#command-history">Modalità interattiva: cronologia dei comandi</a>

39</div>

41<div className="digest-wins">

42 <p className="digest-wins-title">Altri vantaggi</p>

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

45 <div>La nuova impostazione <code>worktree.baseRef</code> (<code>fresh</code> | <code>head</code>) controlla se <code>--worktree</code>, lo strumento <code>EnterWorktree</code> e i worktrees di isolamento dell'agente si diramano dal ramo predefinito remoto o dal <code>HEAD</code> locale; il valore predefinito <code>fresh</code> mantiene i commit non sottoposti a push fuori dai nuovi worktrees</div>

46 <div>Le nuove regole <code>settings.autoMode.hard\_deny</code> bloccano le azioni corrispondenti in modo incondizionato in modalità auto, indipendentemente dalle eccezioni di autorizzazione, per le azioni che non dovrebbero mai essere eseguite automaticamente anche quando si applicano regole di autorizzazione più ampie</div>

47 <div>Gli hook ora ricevono il livello di sforzo attivo tramite il campo di input JSON `effort.level` e la variabile di ambiente `$CLAUDE_EFFORT`, e i comandi dello strumento Bash possono leggere <code>\$CLAUDE\_EFFORT</code></div>

48 <div><code>CLAUDE\_CODE\_DISABLE\_ALTERNATE\_SCREEN=1</code> rinuncia al renderer fullscreen alternate-screen e mantiene la conversazione nello scrollback nativo del terminale</div>

49 <div><code>CLAUDE\_CODE\_PACKAGE\_MANAGER\_AUTO\_UPDATE</code> consente alle installazioni Homebrew o WinGet di eseguire l'aggiornamento in background e di richiedere il riavvio</div>

50 <div><code>CLAUDE\_CODE\_SESSION\_ID</code> è ora nell'ambiente del sottoprocesso Bash, corrispondente al `session_id` passato agli hook</div>

51 <div><code>/mcp</code> ora mostra il conteggio degli strumenti per i server connessi e contrassegna i server che si sono connessi con 0 strumenti</div>

52 <div><code>--channels</code> ora funziona con l'autenticazione della console (chiave API)</div>

53 <div>I sottoprocessi come Bash, hook, MCP e LSP non ereditano più le variabili di ambiente <code>OTEL\_\*</code>, quindi le app strumentate OTEL eseguite tramite lo strumento Bash non raccolgono più l'endpoint OTLP del CLI</div>

54 <div>I riepiloghi di avanzamento del sub-agente ora raggiungono la cache dei prompt, riducendo il costo del token <code>cache\_creation</code> di circa 3 volte</div>

55 <div>Diversi fix di affidabilità OAuth e credenziali: le sessioni parallele non si bloccano più a 401 dopo una race di refresh-token, i token di refresh OAuth di MCP non vengono più persi quando più server si aggiornano contemporaneamente, e una rara loop di login da una scrittura di credenziale concorrente è stata corretta</div>

56 <div>La nuova chiave admin <code>parentSettingsBehavior</code> consente agli amministratori di optare per SDK <code>managedSettings</code> nel merge delle policy</div>

57 </div>

58</div>

60[Changelog completo per v2.1.128–v2.1.136 →](/it/changelog#2-1-128)

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