Documentation — Spybara

agent-sdk/custom-tools.md +833 −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# Fornisci a Claude strumenti personalizzati

7> Definisci strumenti personalizzati con il server MCP in-process dell'Agent SDK di Claude in modo che Claude possa chiamare le tue funzioni, accedere alle tue API ed eseguire operazioni specifiche del dominio.

9Gli strumenti personalizzati estendono l'Agent SDK permettendoti di definire le tue funzioni che Claude può chiamare durante una conversazione. Utilizzando il server MCP in-process dell'SDK, puoi dare a Claude accesso a database, API esterne, logica specifica del dominio o qualsiasi altra capacità di cui la tua applicazione ha bisogno.

11Questa guida copre come definire strumenti con schemi di input e handler, raggrupparli in un server MCP, passarli a `query` e controllare a quali strumenti Claude può accedere. Copre anche la gestione degli errori, le annotazioni degli strumenti e la restituzione di contenuti non testuali come immagini.

13## Riferimento rapido

15| Se vuoi... | Fai questo |

16| :------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

17| Definire uno strumento | Usa [`@tool`](/it/agent-sdk/python#tool) (Python) o [`tool()`](/it/agent-sdk/typescript#tool) (TypeScript) con un nome, una descrizione, uno schema e un handler. Vedi [Creare uno strumento personalizzato](#create-a-custom-tool). |

18| Registrare uno strumento con Claude | Avvolgi in `create_sdk_mcp_server` / `createSdkMcpServer` e passa a `mcpServers` in `query()`. Vedi [Chiamare uno strumento personalizzato](#call-a-custom-tool). |

19| Pre-approvare uno strumento | Aggiungi ai tuoi strumenti consentiti. Vedi [Configurare gli strumenti consentiti](#configure-allowed-tools). |

20| Rimuovere uno strumento integrato dal contesto di Claude | Passa un array `tools` elencando solo gli strumenti integrati che desideri. Vedi [Configurare gli strumenti consentiti](#configure-allowed-tools). |

21| Permettere a Claude di chiamare strumenti in parallelo | Imposta `readOnlyHint: true` su strumenti senza effetti collaterali. Vedi [Aggiungere annotazioni degli strumenti](#add-tool-annotations). |

22| Gestire gli errori senza interrompere il ciclo | Restituisci `isError: true` invece di lanciare un'eccezione. Vedi [Gestire gli errori](#handle-errors). |

23| Restituire immagini o file | Usa blocchi `image` o `resource` nell'array di contenuti. Vedi [Restituire immagini e risorse](#return-images-and-resources). |

24| Restituire un risultato JSON leggibile da macchina | Imposta `structuredContent` sul risultato. Vedi [Restituire dati strutturati](#return-structured-data). |

25| Scalare a molti strumenti | Usa [tool search](/it/agent-sdk/tool-search) per caricare gli strumenti su richiesta. |

27## Creare uno strumento personalizzato

29Uno strumento è definito da quattro parti, passate come argomenti al helper [`tool()`](/it/agent-sdk/typescript#tool) in TypeScript o al decoratore [`@tool`](/it/agent-sdk/python#tool) in Python:

31* **Nome:** un identificatore univoco che Claude usa per chiamare lo strumento.

32* **Descrizione:** cosa fa lo strumento. Claude legge questo per decidere quando chiamarlo.

33* **Schema di input:** gli argomenti che Claude deve fornire. In TypeScript questo è sempre uno [schema Zod](https://zod.dev/), e gli `args` dell'handler sono tipizzati automaticamente da esso. In Python questo è un dict che mappa nomi a tipi, come `{"latitude": float}`, che l'SDK converte in JSON Schema per te. Il decoratore Python accetta anche un dict completo di [JSON Schema](https://json-schema.org/understanding-json-schema/about) direttamente quando hai bisogno di enum, intervalli, campi opzionali o oggetti annidati.

34* **Handler:** la funzione asincrona che viene eseguita quando Claude chiama lo strumento. Riceve gli argomenti convalidati e deve restituire un oggetto con:

35 * `content` (obbligatorio): un array di blocchi di risultato, ognuno con un `type` di `"text"`, `"image"` o `"resource"`. Vedi [Restituire immagini e risorse](#return-images-and-resources) per blocchi non testuali.

36 * `structuredContent` (opzionale): un oggetto JSON che contiene il risultato come dati leggibili da macchina, restituito insieme a `content`. Vedi [Restituire dati strutturati](#return-structured-data).

37 * `isError` (opzionale): imposta su `true` per segnalare un fallimento dello strumento in modo che Claude possa reagire. Vedi [Gestire gli errori](#handle-errors).

39Dopo aver definito uno strumento, avvolgilo in un server con [`createSdkMcpServer`](/it/agent-sdk/typescript#createsdkmcpserver) (TypeScript) o [`create_sdk_mcp_server`](/it/agent-sdk/python#create_sdk_mcp_server) (Python). Il server viene eseguito in-process all'interno della tua applicazione, non come processo separato.

41### Esempio di strumento meteo

43Questo esempio definisce uno strumento `get_temperature` e lo avvolge in un server MCP. Configura solo lo strumento; per passarlo a `query` e eseguirlo, vedi [Chiamare uno strumento personalizzato](#call-a-custom-tool) di seguito.

45<CodeGroup>

46 ```python Python theme={null}

47 from typing import Any

48 import httpx

49 from claude_agent_sdk import tool, create_sdk_mcp_server

52 # Define a tool: name, description, input schema, handler

53 @tool(

54 "get_temperature",

55 "Get the current temperature at a location",

56 {"latitude": float, "longitude": float},

57 )

58 async def get_temperature(args: dict[str, Any]) -> dict[str, Any]:

59 async with httpx.AsyncClient() as client:

60 response = await client.get(

61 "https://api.open-meteo.com/v1/forecast",

62 params={

63 "latitude": args["latitude"],

64 "longitude": args["longitude"],

65 "current": "temperature_2m",

66 "temperature_unit": "fahrenheit",

67 },

68 )

69 data = response.json()

71 # Return a content array - Claude sees this as the tool result

72 return {

73 "content": [

74 {

75 "type": "text",

76 "text": f"Temperature: {data['current']['temperature_2m']}°F",

77 }

78 ]

79 }

82 # Wrap the tool in an in-process MCP server

83 weather_server = create_sdk_mcp_server(

84 name="weather",

85 version="1.0.0",

86 tools=[get_temperature],

87 )

88 ```

90 ```typescript TypeScript theme={null}

91 import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";

92 import { z } from "zod";

94 // Define a tool: name, description, input schema, handler

95 const getTemperature = tool(

96 "get_temperature",

97 "Get the current temperature at a location",

98 {

99 latitude: z.number().describe("Latitude coordinate"), // .describe() adds a field description Claude sees

100 longitude: z.number().describe("Longitude coordinate")

101 },

102 async (args) => {

103 // args is typed from the schema: { latitude: number; longitude: number }

104 const response = await fetch(

105 `https://api.open-meteo.com/v1/forecast?latitude=${args.latitude}&longitude=${args.longitude}&current=temperature_2m&temperature_unit=fahrenheit`

106 );

107 const data: any = await response.json();

108

109 // Return a content array - Claude sees this as the tool result

110 return {

111 content: [{ type: "text", text: `Temperature: ${data.current.temperature_2m}°F` }]

112 };

113 }

114 );

115

116 // Wrap the tool in an in-process MCP server

117 const weatherServer = createSdkMcpServer({

118 name: "weather",

119 version: "1.0.0",

120 tools: [getTemperature]

121 });

122 ```

123</CodeGroup>

124

125Vedi il riferimento TypeScript [`tool()`](/it/agent-sdk/typescript#tool) o il riferimento Python [`@tool`](/it/agent-sdk/python#tool) per i dettagli completi dei parametri, inclusi i formati di input JSON Schema e la struttura del valore di ritorno.

126

127<Tip>

128 Per rendere un parametro opzionale: in TypeScript, aggiungi `.default()` al campo Zod. In Python, lo schema dict tratta ogni chiave come obbligatoria, quindi ometti il parametro dallo schema, menzionalo nella stringa di descrizione e leggilo con `args.get()` nell'handler. Lo strumento [`get_precipitation_chance` di seguito](#add-more-tools) mostra entrambi i pattern.

129</Tip>

130

131### Chiamare uno strumento personalizzato

132

133Passa il server MCP che hai creato a `query` tramite l'opzione `mcpServers`. La chiave in `mcpServers` diventa il segmento `{server_name}` nel nome completamente qualificato di ogni strumento: `mcp__{server_name}__{tool_name}`. Elenca quel nome in `allowedTools` in modo che lo strumento venga eseguito senza un prompt di autorizzazione.

134

135Questi snippet riutilizzano il `weatherServer` dall'[esempio precedente](#weather-tool-example) per chiedere a Claude qual è il meteo in una posizione specifica.

136

137<CodeGroup>

138 ```python Python theme={null}

139 import asyncio

140 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

141

142

143 async def main():

144 options = ClaudeAgentOptions(

145 mcp_servers={"weather": weather_server},

146 allowed_tools=["mcp__weather__get_temperature"],

147 )

148

149 async for message in query(

150 prompt="What's the temperature in San Francisco?",

151 options=options,

152 ):

153 # ResultMessage is the final message after all tool calls complete

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

155 print(message.result)

156

157

158 asyncio.run(main())

159 ```

160

161 ```typescript TypeScript theme={null}

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

163

164 for await (const message of query({

165 prompt: "What's the temperature in San Francisco?",

166 options: {

167 mcpServers: { weather: weatherServer },

168 allowedTools: ["mcp__weather__get_temperature"]

169 }

170 })) {

171 // "result" is the final message after all tool calls complete

172 if (message.type === "result" && message.subtype === "success") {

173 console.log(message.result);

174 }

175 }

176 ```

177</CodeGroup>

178

179### Aggiungere più strumenti

180

181Un server contiene quanti strumenti elenchi nel suo array `tools`. Con più di uno strumento su un server, puoi elencare ognuno in `allowedTools` individualmente o usare il wildcard `mcp__weather__*` per coprire ogni strumento che il server espone.

182

183L'esempio di seguito aggiunge un secondo strumento, `get_precipitation_chance`, al `weatherServer` dall'[esempio di strumento meteo](#weather-tool-example) e lo ricostruisce con entrambi gli strumenti nell'array.

184

185<CodeGroup>

186 ```python Python theme={null}

187 # Define a second tool for the same server

188 @tool(

189 "get_precipitation_chance",

190 "Get the hourly precipitation probability for a location. "

191 "Optionally pass 'hours' (1-24) to control how many hours to return.",

192 {"latitude": float, "longitude": float},

193 )

194 async def get_precipitation_chance(args: dict[str, Any]) -> dict[str, Any]:

195 # 'hours' isn't in the schema - read it with .get() to make it optional

196 hours = args.get("hours", 12)

197 async with httpx.AsyncClient() as client:

198 response = await client.get(

199 "https://api.open-meteo.com/v1/forecast",

200 params={

201 "latitude": args["latitude"],

202 "longitude": args["longitude"],

203 "hourly": "precipitation_probability",

204 "forecast_days": 1,

205 },

206 )

207 data = response.json()

208 chances = data["hourly"]["precipitation_probability"][:hours]

209

210 return {

211 "content": [

212 {

213 "type": "text",

214 "text": f"Next {hours} hours: {'%, '.join(map(str, chances))}%",

215 }

216 ]

217 }

218

219

220 # Rebuild the server with both tools in the array

221 weather_server = create_sdk_mcp_server(

222 name="weather",

223 version="1.0.0",

224 tools=[get_temperature, get_precipitation_chance],

225 )

226 ```

227

228 ```typescript TypeScript theme={null}

229 // Define a second tool for the same server

230 const getPrecipitationChance = tool(

231 "get_precipitation_chance",

232 "Get the hourly precipitation probability for a location",

233 {

234 latitude: z.number(),

235 longitude: z.number(),

236 hours: z

237 .number()

238 .int()

239 .min(1)

240 .max(24)

241 .default(12) // .default() makes the parameter optional

242 .describe("How many hours of forecast to return")

243 },

244 async (args) => {

245 const response = await fetch(

246 `https://api.open-meteo.com/v1/forecast?latitude=${args.latitude}&longitude=${args.longitude}&hourly=precipitation_probability&forecast_days=1`

247 );

248 const data: any = await response.json();

249 const chances = data.hourly.precipitation_probability.slice(0, args.hours);

250

251 return {

252 content: [{ type: "text", text: `Next ${args.hours} hours: ${chances.join("%, ")}%` }]

253 };

254 }

255 );

256

257 // Rebuild the server with both tools in the array

258 const weatherServer = createSdkMcpServer({

259 name: "weather",

260 version: "1.0.0",

261 tools: [getTemperature, getPrecipitationChance]

262 });

263 ```

264</CodeGroup>

265

266Ogni strumento in questo array consuma spazio della finestra di contesto ad ogni turno. Se stai definendo dozzine di strumenti, vedi [tool search](/it/agent-sdk/tool-search) per caricarli su richiesta invece.

267

268### Aggiungere annotazioni degli strumenti

269

270Le [annotazioni degli strumenti](https://modelcontextprotocol.io/docs/concepts/tools#tool-annotations) sono metadati opzionali che descrivono come si comporta uno strumento. Passali come quinto argomento al helper `tool()` in TypeScript o tramite l'argomento della parola chiave `annotations` per il decoratore `@tool` in Python. Tutti i campi hint sono booleani.

271

272| Campo | Predefinito | Significato |

273| :---------------- | :---------- | :----------------------------------------------------------------------------------------------------------------------------------------- |

274| `readOnlyHint` | `false` | Lo strumento non modifica il suo ambiente. Controlla se lo strumento può essere chiamato in parallelo con altri strumenti di sola lettura. |

275| `destructiveHint` | `true` | Lo strumento può eseguire aggiornamenti distruttivi. Solo informativo. |

276| `idempotentHint` | `false` | Le chiamate ripetute con gli stessi argomenti non hanno effetti aggiuntivi. Solo informativo. |

277| `openWorldHint` | `true` | Lo strumento raggiunge sistemi al di fuori del tuo processo. Solo informativo. |

278

279Le annotazioni sono metadati, non applicazione. Uno strumento contrassegnato con `readOnlyHint: true` può comunque scrivere su disco se è quello che fa l'handler. Mantieni l'annotazione accurata rispetto all'handler.

280

281Questo esempio aggiunge `readOnlyHint` allo strumento `get_temperature` dall'[esempio di strumento meteo](#weather-tool-example).

282

283<CodeGroup>

284 ```python Python theme={null}

285 from claude_agent_sdk import tool, ToolAnnotations

286

287

288 @tool(

289 "get_temperature",

290 "Get the current temperature at a location",

291 {"latitude": float, "longitude": float},

292 annotations=ToolAnnotations(

293 readOnlyHint=True

294 ), # Lets Claude batch this with other read-only calls

295 )

296 async def get_temperature(args):

297 return {"content": [{"type": "text", "text": "..."}]}

298 ```

299

300 ```typescript TypeScript theme={null}

301 tool(

302 "get_temperature",

303 "Get the current temperature at a location",

304 { latitude: z.number(), longitude: z.number() },

305 async (args) => ({ content: [{ type: "text", text: `...` }] }),

306 { annotations: { readOnlyHint: true } } // Lets Claude batch this with other read-only calls

307 );

308 ```

309</CodeGroup>

310

311Vedi `ToolAnnotations` nel riferimento [TypeScript](/it/agent-sdk/typescript#toolannotations) o [Python](/it/agent-sdk/python#toolannotations).

312

313## Controllare l'accesso agli strumenti

314

315L'[esempio di strumento meteo](#weather-tool-example) ha registrato un server e elencato gli strumenti in `allowedTools`. Questa sezione copre come vengono costruiti i nomi degli strumenti e come limitare l'accesso quando hai più strumenti o vuoi limitare gli strumenti integrati.

316

317### Formato del nome dello strumento

318

319Quando gli strumenti MCP vengono esposti a Claude, i loro nomi seguono un formato specifico:

320

321* Pattern: `mcp__{server_name}__{tool_name}`

322* Esempio: Uno strumento denominato `get_temperature` nel server `weather` diventa `mcp__weather__get_temperature`

323

324### Configurare gli strumenti consentiti

325

326L'opzione `tools` e gli elenchi consentiti/non consentiti operano su livelli separati. `tools` controlla quali strumenti integrati appaiono nel contesto di Claude. Gli elenchi di strumenti consentiti e non consentiti controllano se le chiamate vengono approvate o negate una volta che Claude tenta di farle.

327

328| Opzione | Livello | Effetto |

329| :------------------------ | :------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

330| `tools: ["Read", "Grep"]` | Disponibilità | Solo gli strumenti integrati elencati sono nel contesto di Claude. Gli strumenti integrati non elencati vengono rimossi. Gli strumenti MCP non sono interessati. |

331| `tools: []` | Disponibilità | Tutti gli strumenti integrati vengono rimossi. Claude può usare solo i tuoi strumenti MCP. |

332| strumenti consentiti | Autorizzazione | Gli strumenti elencati vengono eseguiti senza un prompt di autorizzazione. Gli strumenti non elencati rimangono disponibili; le chiamate passano attraverso il [flusso di autorizzazione](/it/agent-sdk/permissions). |

333| strumenti non consentiti | Autorizzazione | Ogni chiamata a uno strumento elencato viene negata. Lo strumento rimane nel contesto di Claude, quindi Claude potrebbe comunque tentarlo prima che la chiamata venga rifiutata. |

334

335Per limitare quali strumenti integrati Claude può usare, preferisci `tools` rispetto agli strumenti non consentiti. Omettere uno strumento da `tools` lo rimuove dal contesto in modo che Claude non lo tenti mai; elencarlo in `disallowedTools` (Python: `disallowed_tools`) blocca la chiamata ma lascia lo strumento visibile, quindi Claude potrebbe sprecare un turno tentandolo. Vedi [Configurare le autorizzazioni](/it/agent-sdk/permissions) per l'ordine di valutazione completo.

336

337## Gestire gli errori

338

339Come il tuo handler segnala gli errori determina se il ciclo dell'agente continua o si ferma:

340

341| Cosa succede | Risultato |

342| :------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------- |

343| L'handler lancia un'eccezione non catturata | Il ciclo dell'agente si ferma. Claude non vede mai l'errore e la chiamata `query` fallisce. |

344| L'handler cattura l'errore e restituisce `isError: true` (TS) / `"is_error": True` (Python) | Il ciclo dell'agente continua. Claude vede l'errore come dati e può riprovare, provare uno strumento diverso o spiegare il fallimento. |

345

346L'esempio di seguito cattura due tipi di fallimenti all'interno dell'handler invece di lasciarli lanciare. Uno stato HTTP non-200 viene catturato dalla risposta e restituito come risultato di errore. Un errore di rete o JSON non valido viene catturato dal `try/except` (Python) o `try/catch` (TypeScript) circostante e viene anche restituito come risultato di errore. In entrambi i casi l'handler restituisce normalmente e il ciclo dell'agente continua.

347

348<CodeGroup>

349 ```python Python theme={null}

350 import json

351 import httpx

352 from typing import Any

353

354

355 @tool(

356 "fetch_data",

357 "Fetch data from an API",

358 {"endpoint": str}, # Simple schema

359 )

360 async def fetch_data(args: dict[str, Any]) -> dict[str, Any]:

361 try:

362 async with httpx.AsyncClient() as client:

363 response = await client.get(args["endpoint"])

364 if response.status_code != 200:

365 # Return the failure as a tool result so Claude can react to it.

366 # is_error marks this as a failed call rather than odd-looking data.

367 return {

368 "content": [

369 {

370 "type": "text",

371 "text": f"API error: {response.status_code} {response.reason_phrase}",

372 }

373 ],

374 "is_error": True,

375 }

376

377 data = response.json()

378 return {"content": [{"type": "text", "text": json.dumps(data, indent=2)}]}

379 except Exception as e:

380 # Catching here keeps the agent loop alive. An uncaught exception

381 # would end the whole query() call.

382 return {

383 "content": [{"type": "text", "text": f"Failed to fetch data: {str(e)}"}],

384 "is_error": True,

385 }

386 ```

387

388 ```typescript TypeScript theme={null}

389 tool(

390 "fetch_data",

391 "Fetch data from an API",

392 {

393 endpoint: z.string().url().describe("API endpoint URL")

394 },

395 async (args) => {

396 try {

397 const response = await fetch(args.endpoint);

398

399 if (!response.ok) {

400 // Return the failure as a tool result so Claude can react to it.

401 // isError marks this as a failed call rather than odd-looking data.

402 return {

403 content: [

404 {

405 type: "text",

406 text: `API error: ${response.status} ${response.statusText}`

407 }

408 ],

409 isError: true

410 };

411 }

412

413 const data = await response.json();

414 return {

415 content: [

416 {

417 type: "text",

418 text: JSON.stringify(data, null, 2)

419 }

420 ]

421 };

422 } catch (error) {

423 // Catching here keeps the agent loop alive. An uncaught throw

424 // would end the whole query() call.

425 return {

426 content: [

427 {

428 type: "text",

429 text: `Failed to fetch data: ${error instanceof Error ? error.message : String(error)}`

430 }

431 ],

432 isError: true

433 };

434 }

435 }

436 );

437 ```

438</CodeGroup>

439

440## Restituire immagini e risorse

441

442L'array `content` in un risultato dello strumento accetta blocchi `text`, `image` e `resource`. Puoi mischiarli nella stessa risposta.

443

444### Immagini

445

446Un blocco immagine trasporta i byte dell'immagine inline, codificati come base64. Non c'è campo URL. Per restituire un'immagine che si trova in un URL, recuperala nell'handler, leggi i byte della risposta e codificali in base64 prima di restituire. Il risultato viene elaborato come input visivo.

447

448| Campo | Tipo | Note |

449| :--------- | :-------- | :-------------------------------------------------------------------------------------- |

450| `type` | `"image"` | |

451| `data` | `string` | Byte codificati in base64. Solo base64 grezzo, nessun prefisso `data:image/...;base64,` |

452| `mimeType` | `string` | Obbligatorio. Ad esempio `image/png`, `image/jpeg`, `image/webp`, `image/gif` |

453

454<CodeGroup>

455 ```python Python theme={null}

456 import base64

457 import httpx

458

459

460 # Define a tool that fetches an image from a URL and returns it to Claude

461 @tool("fetch_image", "Fetch an image from a URL and return it to Claude", {"url": str})

462 async def fetch_image(args):

463 async with httpx.AsyncClient() as client: # Fetch the image bytes

464 response = await client.get(args["url"])

465

466 return {

467 "content": [

468 {

469 "type": "image",

470 "data": base64.b64encode(response.content).decode(

471 "ascii"

472 ), # Base64-encode the raw bytes

473 "mimeType": response.headers.get(

474 "content-type", "image/png"

475 ), # Read MIME type from the response

476 }

477 ]

478 }

479 ```

480

481 ```typescript TypeScript theme={null}

482 tool(

483 "fetch_image",

484 "Fetch an image from a URL and return it to Claude",

485 {

486 url: z.string().url()

487 },

488 async (args) => {

489 const response = await fetch(args.url); // Fetch the image bytes

490 const buffer = Buffer.from(await response.arrayBuffer()); // Read into a Buffer for base64 encoding

491 const mimeType = response.headers.get("content-type") ?? "image/png";

492

493 return {

494 content: [

495 {

496 type: "image",

497 data: buffer.toString("base64"), // Base64-encode the raw bytes

498 mimeType

499 }

500 ]

501 };

502 }

503 );

504 ```

505</CodeGroup>

506

507### Risorse

508

509Un blocco risorsa incorpora un pezzo di contenuto identificato da un URI. L'URI è un'etichetta per Claude da riferire; il contenuto effettivo si trova nel campo `text` o `blob` del blocco. Usa questo quando il tuo strumento produce qualcosa che ha senso affrontare per nome in seguito, come un file generato o un record da un sistema esterno.

510

511| Campo | Tipo | Note |

512| :------------------ | :----------- | :--------------------------------------------------------------- |

513| `type` | `"resource"` | |

514| `resource.uri` | `string` | Identificatore per il contenuto. Qualsiasi schema URI |

515| `resource.text` | `string` | Il contenuto, se è testo. Fornisci questo o `blob`, non entrambi |

516| `resource.blob` | `string` | Il contenuto codificato in base64, se è binario |

517| `resource.mimeType` | `string` | Opzionale |

518

519Questo esempio mostra un blocco risorsa restituito dall'interno di un handler dello strumento. L'URI `file:///tmp/report.md` è un'etichetta che Claude può riferire in seguito; l'SDK non legge da quel percorso.

520

521<CodeGroup>

522 ```typescript TypeScript theme={null}

523 return {

524 content: [

525 {

526 type: "resource",

527 resource: {

528 uri: "file:///tmp/report.md", // Label for Claude to reference, not a path the SDK reads

529 mimeType: "text/markdown",

530 text: "# Report\n..." // The actual content, inline

531 }

532 }

533 ]

534 };

535 ```

536

537 ```python Python theme={null}

538 return {

539 "content": [

540 {

541 "type": "resource",

542 "resource": {

543 "uri": "file:///tmp/report.md", # Label for Claude to reference, not a path the SDK reads

544 "mimeType": "text/markdown",

545 "text": "# Report\n...", # The actual content, inline

546 },

547 }

548 ]

549 }

550 ```

551</CodeGroup>

552

553Queste forme di blocco provengono dal tipo MCP `CallToolResult`. Vedi la [specifica MCP](https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-result) per la definizione completa.

554

555## Restituire dati strutturati

556

557`structuredContent` è un oggetto JSON opzionale sul risultato, separato dall'array `content`. Usalo per restituire valori grezzi che Claude può leggere come campi esatti invece di analizzarli da una stringa di testo o da un'immagine.

558

559Quando `structuredContent` è impostato, Claude riceve il JSON più eventuali blocchi di immagine o risorsa da `content`. I blocchi di testo in `content` non vengono inoltrati, poiché si presume che duplichino i dati strutturati. L'esempio di seguito renderizza un grafico come blocco immagine e restituisce i punti dati dietro di esso in `structuredContent` dallo stesso handler.

560

561```typescript TypeScript theme={null}

562return {

563 content: [

564 {

565 type: "image",

566 data: chartPngBuffer.toString("base64"),

567 mimeType: "image/png"

568 }

569 ],

570 structuredContent: {

571 series: "temperature_2m",

572 unit: "fahrenheit",

573 points: [62.1, 63.4, 65.0, 64.2]

574 }

575};

576```

577

578<Note>

579 Il decoratore Python `@tool` inoltro solo `content` e `is_error` dal dict di ritorno dell'handler. Per restituire `structuredContent` da Python, esegui un [server MCP standalone](/it/agent-sdk/mcp) invece di un server SDK in-process.

580</Note>

581

582## Esempio: convertitore di unità

583

584Questo strumento converte valori tra unità di lunghezza, temperatura e peso. Un utente può chiedere "converti 100 chilometri in miglia" o "quanto è 72°F in Celsius", e Claude sceglie il tipo di unità e le unità corrette dalla richiesta.

585

586Dimostra due pattern:

587

588* **Schemi enum:** `unit_type` è vincolato a un insieme fisso di valori. In TypeScript, usa `z.enum()`. In Python, lo schema dict non supporta enum, quindi è richiesto il dict JSON Schema completo.

589* **Gestione dell'input non supportato:** quando una coppia di conversione non viene trovata, l'handler restituisce `isError: true` in modo che Claude possa dire all'utente cosa è andato storto invece di trattare un fallimento come un risultato normale.

590

591<CodeGroup>

592 ```python Python theme={null}

593 from typing import Any

594 from claude_agent_sdk import tool, create_sdk_mcp_server

595

596

597 # z.enum() in TypeScript becomes an "enum" constraint in JSON Schema.

598 # The dict schema has no equivalent, so full JSON Schema is required.

599 @tool(

600 "convert_units",

601 "Convert a value from one unit to another",

602 {

603 "type": "object",

604 "properties": {

605 "unit_type": {

606 "type": "string",

607 "enum": ["length", "temperature", "weight"],

608 "description": "Category of unit",

609 },

610 "from_unit": {

611 "type": "string",

612 "description": "Unit to convert from, e.g. kilometers, fahrenheit, pounds",

613 },

614 "to_unit": {"type": "string", "description": "Unit to convert to"},

615 "value": {"type": "number", "description": "Value to convert"},

616 },

617 "required": ["unit_type", "from_unit", "to_unit", "value"],

618 },

619 )

620 async def convert_units(args: dict[str, Any]) -> dict[str, Any]:

621 conversions = {

622 "length": {

623 "kilometers_to_miles": lambda v: v * 0.621371,

624 "miles_to_kilometers": lambda v: v * 1.60934,

625 "meters_to_feet": lambda v: v * 3.28084,

626 "feet_to_meters": lambda v: v * 0.3048,

627 },

628 "temperature": {

629 "celsius_to_fahrenheit": lambda v: (v * 9) / 5 + 32,

630 "fahrenheit_to_celsius": lambda v: (v - 32) * 5 / 9,

631 "celsius_to_kelvin": lambda v: v + 273.15,

632 "kelvin_to_celsius": lambda v: v - 273.15,

633 },

634 "weight": {

635 "kilograms_to_pounds": lambda v: v * 2.20462,

636 "pounds_to_kilograms": lambda v: v * 0.453592,

637 "grams_to_ounces": lambda v: v * 0.035274,

638 "ounces_to_grams": lambda v: v * 28.3495,

639 },

640 }

641

642 key = f"{args['from_unit']}_to_{args['to_unit']}"

643 fn = conversions.get(args["unit_type"], {}).get(key)

644

645 if not fn:

646 return {

647 "content": [

648 {

649 "type": "text",

650 "text": f"Unsupported conversion: {args['from_unit']} to {args['to_unit']}",

651 }

652 ],

653 "is_error": True,

654 }

655

656 result = fn(args["value"])

657 return {

658 "content": [

659 {

660 "type": "text",

661 "text": f"{args['value']} {args['from_unit']} = {result:.4f} {args['to_unit']}",

662 }

663 ]

664 }

665

666

667 converter_server = create_sdk_mcp_server(

668 name="converter",

669 version="1.0.0",

670 tools=[convert_units],

671 )

672 ```

673

674 ```typescript TypeScript theme={null}

675 import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";

676 import { z } from "zod";

677

678 const convert = tool(

679 "convert_units",

680 "Convert a value from one unit to another",

681 {

682 unit_type: z.enum(["length", "temperature", "weight"]).describe("Category of unit"),

683 from_unit: z

684 .string()

685 .describe("Unit to convert from, e.g. kilometers, fahrenheit, pounds"),

686 to_unit: z.string().describe("Unit to convert to"),

687 value: z.number().describe("Value to convert")

688 },

689 async (args) => {

690 type Conversions = Record<string, Record<string, (v: number) => number>>;

691

692 const conversions: Conversions = {

693 length: {

694 kilometers_to_miles: (v) => v * 0.621371,

695 miles_to_kilometers: (v) => v * 1.60934,

696 meters_to_feet: (v) => v * 3.28084,

697 feet_to_meters: (v) => v * 0.3048

698 },

699 temperature: {

700 celsius_to_fahrenheit: (v) => (v * 9) / 5 + 32,

701 fahrenheit_to_celsius: (v) => ((v - 32) * 5) / 9,

702 celsius_to_kelvin: (v) => v + 273.15,

703 kelvin_to_celsius: (v) => v - 273.15

704 },

705 weight: {

706 kilograms_to_pounds: (v) => v * 2.20462,

707 pounds_to_kilograms: (v) => v * 0.453592,

708 grams_to_ounces: (v) => v * 0.035274,

709 ounces_to_grams: (v) => v * 28.3495

710 }

711 };

712

713 const key = `${args.from_unit}_to_${args.to_unit}`;

714 const fn = conversions[args.unit_type]?.[key];

715

716 if (!fn) {

717 return {

718 content: [

719 {

720 type: "text",

721 text: `Unsupported conversion: ${args.from_unit} to ${args.to_unit}`

722 }

723 ],

724 isError: true

725 };

726 }

727

728 const result = fn(args.value);

729 return {

730 content: [

731 {

732 type: "text",

733 text: `${args.value} ${args.from_unit} = ${result.toFixed(4)} ${args.to_unit}`

734 }

735 ]

736 };

737 }

738 );

739

740 const converterServer = createSdkMcpServer({

741 name: "converter",

742 version: "1.0.0",

743 tools: [convert]

744 });

745 ```

746</CodeGroup>

747

748Una volta definito il server, passalo a `query` nello stesso modo dell'esempio meteo. Questo esempio invia tre prompt diversi in un ciclo per mostrare lo stesso strumento che gestisce diversi tipi di unità. Per ogni risposta, ispeziona gli oggetti `AssistantMessage` (che contengono le chiamate dello strumento che Claude ha fatto durante quel turno) e stampa ogni `ToolUseBlock` prima di stampare il testo finale di `ResultMessage`. Questo ti permette di vedere quando Claude sta usando lo strumento rispetto a rispondere dalla sua stessa conoscenza.

749

750<CodeGroup>

751 ```python Python theme={null}

752 import asyncio

753 from claude_agent_sdk import (

754 query,

755 ClaudeAgentOptions,

756 ResultMessage,

757 AssistantMessage,

758 ToolUseBlock,

759 )

760

761

762 async def main():

763 options = ClaudeAgentOptions(

764 mcp_servers={"converter": converter_server},

765 allowed_tools=["mcp__converter__convert_units"],

766 )

767

768 prompts = [

769 "Convert 100 kilometers to miles.",

770 "What is 72°F in Celsius?",

771 "How many pounds is 5 kilograms?",

772 ]

773

774 for prompt in prompts:

775 async for message in query(prompt=prompt, options=options):

776 if isinstance(message, AssistantMessage):

777 for block in message.content:

778 if isinstance(block, ToolUseBlock):

779 print(f"[tool call] {block.name}({block.input})")

780 elif isinstance(message, ResultMessage) and message.subtype == "success":

781 print(f"Q: {prompt}\nA: {message.result}\n")

782

783

784 asyncio.run(main())

785 ```

786

787 ```typescript TypeScript theme={null}

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

789

790 const prompts = [

791 "Convert 100 kilometers to miles.",

792 "What is 72°F in Celsius?",

793 "How many pounds is 5 kilograms?"

794 ];

795

796 for (const prompt of prompts) {

797 for await (const message of query({

798 prompt,

799 options: {

800 mcpServers: { converter: converterServer },

801 allowedTools: ["mcp__converter__convert_units"]

802 }

803 })) {

804 if (message.type === "assistant") {

805 for (const block of message.message.content) {

806 if (block.type === "tool_use") {

807 console.log(`[tool call] ${block.name}`, block.input);

808 }

809 }

810 } else if (message.type === "result" && message.subtype === "success") {

811 console.log(`Q: ${prompt}\nA: ${message.result}\n`);

812 }

813 }

814 }

815 ```

816</CodeGroup>

817

818## Passaggi successivi

819

820Gli strumenti personalizzati avvolgono funzioni asincrone in un'interfaccia standard. Puoi mescolare i pattern su questa pagina nello stesso server: un singolo server può contenere uno strumento di database, uno strumento di gateway API e un renderer di immagini uno accanto all'altro.

821

822Da qui:

823

824* Se il tuo server cresce fino a dozzine di strumenti, vedi [tool search](/it/agent-sdk/tool-search) per differire il caricamento fino a quando Claude ne ha bisogno.

825* Per connettersi a server MCP esterni (filesystem, GitHub, Slack) invece di costruire il tuo, vedi [Connetti server MCP](/it/agent-sdk/mcp).

826* Per controllare quali strumenti vengono eseguiti automaticamente rispetto a quelli che richiedono approvazione, vedi [Configurare le autorizzazioni](/it/agent-sdk/permissions).

827

828## Documentazione correlata

829

830* [Riferimento SDK TypeScript](/it/agent-sdk/typescript)

831* [Riferimento SDK Python](/it/agent-sdk/python)

832* [Documentazione MCP](https://modelcontextprotocol.io)

833* [Panoramica SDK](/it/agent-sdk/overview)

agent-sdk/python.md +46 −7

Details

757 allowed_tools: list[str] = field(default_factory=list)757 allowed_tools: list[str] = field(default_factory=list)

758 system_prompt: str | SystemPromptPreset | None = None758 system_prompt: str | SystemPromptPreset | None = None

759 mcp_servers: dict[str, McpServerConfig] | str | Path = field(default_factory=dict)759 mcp_servers: dict[str, McpServerConfig] | str | Path = field(default_factory=dict)

760 strict_mcp_config: bool = False

760 permission_mode: PermissionMode | None = None761 permission_mode: PermissionMode | None = None

761 continue_conversation: bool = False762 continue_conversation: bool = False

762 resume: str | None = None763 resume: str | None = None

781 hooks: dict[HookEvent, list[HookMatcher]] | None = None782 hooks: dict[HookEvent, list[HookMatcher]] | None = None

782 user: str | None = None783 user: str | None = None

783 include_partial_messages: bool = False784 include_partial_messages: bool = False

785 include_hook_events: bool = False

784 fork_session: bool = False786 fork_session: bool = False

785 agents: dict[str, AgentDefinition] | None = None787 agents: dict[str, AgentDefinition] | None = None

786 setting_sources: list[SettingSource] | None = None788 setting_sources: list[SettingSource] | None = None

788 plugins: list[SdkPluginConfig] = field(default_factory=list)790 plugins: list[SdkPluginConfig] = field(default_factory=list)

789 max_thinking_tokens: int | None = None # Deprecated: use thinking instead791 max_thinking_tokens: int | None = None # Deprecated: use thinking instead

790 thinking: ThinkingConfig | None = None792 thinking: ThinkingConfig | None = None

791 effort: Literal["low", "medium", "high", "max"] | None = None793 effort: Literal["low", "medium", "high", "xhigh", "max"] | None = None

792 enable_file_checkpointing: bool = False794 enable_file_checkpointing: bool = False

793 session_store: SessionStore | None = None795 session_store: SessionStore | None = None

794 session_store_flush: SessionStoreFlushMode = "batched"796 session_store_flush: SessionStoreFlushMode = "batched"

800| `allowed_tools` | `list[str]` | `[]` | Strumenti da approvare automaticamente senza chiedere. Questo non limita Claude a solo questi strumenti; gli strumenti non elencati ricadono in `permission_mode` e `can_use_tool`. Usa `disallowed_tools` per bloccare gli strumenti. Vedi [Autorizzazioni](/it/agent-sdk/permissions#allow-and-deny-rules) |802| `allowed_tools` | `list[str]` | `[]` | Strumenti da approvare automaticamente senza chiedere. Questo non limita Claude a solo questi strumenti; gli strumenti non elencati ricadono in `permission_mode` e `can_use_tool`. Usa `disallowed_tools` per bloccare gli strumenti. Vedi [Autorizzazioni](/it/agent-sdk/permissions#allow-and-deny-rules) |

801| `system_prompt` | `str \| SystemPromptPreset \| None` | `None` | Configurazione del prompt di sistema. Passa una stringa per un prompt personalizzato, o usa `{"type": "preset", "preset": "claude_code"}` per il prompt di sistema di Claude Code. Aggiungi `"append"` per estendere il preset |803| `system_prompt` | `str \| SystemPromptPreset \| None` | `None` | Configurazione del prompt di sistema. Passa una stringa per un prompt personalizzato, o usa `{"type": "preset", "preset": "claude_code"}` per il prompt di sistema di Claude Code. Aggiungi `"append"` per estendere il preset |

802| `mcp_servers` | `dict[str, McpServerConfig] \| str \| Path` | `{}` | Configurazioni del server MCP o percorso al file di configurazione |804| `mcp_servers` | `dict[str, McpServerConfig] \| str \| Path` | `{}` | Configurazioni del server MCP o percorso al file di configurazione |

805| `strict_mcp_config` | `bool` | `False` | Quando `True`, usa solo i server passati in `mcp_servers` e ignora il progetto `.mcp.json`, le impostazioni utente e i server MCP forniti dai plugin. Mappa al flag CLI `--strict-mcp-config` |

819| `env` | `dict[str, str]` | `{}` | Variabili di ambiente unite in cima all'ambiente del processo ereditato. Vedi [Variabili di ambiente](/it/env-vars) per le variabili che la CLI sottostante legge |822| `env` | `dict[str, str]` | `{}` | Variabili di ambiente unite in cima all'ambiente del processo ereditato. Vedi [Variabili di ambiente](/it/env-vars) per le variabili che la CLI sottostante legge, e [Gestisci risposte API lente o bloccate](#handle-slow-or-stalled-api-responses) per le variabili relative ai timeout |

820| `extra_args` | `dict[str, str \| None]` | `{}` | Argomenti CLI aggiuntivi da passare direttamente alla CLI |823| `extra_args` | `dict[str, str \| None]` | `{}` | Argomenti CLI aggiuntivi da passare direttamente alla CLI |

832| `setting_sources` | `list[SettingSource] \| None` | `None` (Impostazioni predefinite CLI: tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzionalità di Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |836| `setting_sources` | `list[SettingSource] \| None` | `None` (Impostazioni predefinite CLI: tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzionalità di Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

836| `session_store` | [`SessionStore`](/it/agent-sdk/session-storage#the-sessionstore-interface) ` \| None` | `None` | Specchia i trascritti di sessione in un backend esterno in modo che qualsiasi host possa riprenderli. Vedi [Persisti le sessioni nell'archiviazione esterna](/it/agent-sdk/session-storage) |840| `session_store` | [`SessionStore`](/it/agent-sdk/session-storage#the-sessionstore-interface) ` \| None` | `None` | Specchia i trascritti di sessione in un backend esterno in modo che qualsiasi host possa riprenderli. Vedi [Persisti le sessioni nell'archiviazione esterna](/it/agent-sdk/session-storage) |

837| `session_store_flush` | `Literal["batched", "eager"]` | `"batched"` | Quando eseguire il flush delle voci di trascritto mirrorato a `session_store`. `"batched"` esegue il flush una volta per turno o quando il buffer si riempie; `"eager"` attiva un flush in background dopo ogni frame. Ignorato quando `session_store` è `None` |841| `session_store_flush` | `Literal["batched", "eager"]` | `"batched"` | Quando eseguire il flush delle voci di trascritto mirrorato a `session_store`. `"batched"` esegue il flush una volta per turno o quando il buffer si riempie; `"eager"` attiva un flush in background dopo ogni frame. Ignorato quando `session_store` è `None` |

838 842

843#### Gestisci risposte API lente o bloccate

844

845Il subprocess CLI legge diverse variabili di ambiente che controllano i timeout dell'API e il rilevamento dei blocchi. Passale attraverso `ClaudeAgentOptions.env`:

846

847```python theme={null}

848options = ClaudeAgentOptions(

849 env={

850 "API_TIMEOUT_MS": "120000",

851 "CLAUDE_CODE_MAX_RETRIES": "2",

852 "CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS": "120000",

853 },

854)

855```

856

857* `API_TIMEOUT_MS`: timeout per richiesta sul client Anthropic, in millisecondi. Predefinito `600000`. Si applica al ciclo principale e a tutti i subagenti.

858* `CLAUDE_CODE_MAX_RETRIES`: numero massimo di tentativi API. Predefinito `10`. Ogni tentativo ottiene la propria finestra `API_TIMEOUT_MS`, quindi il tempo di parete nel caso peggiore è approssimativamente `API_TIMEOUT_MS × (CLAUDE_CODE_MAX_RETRIES + 1)` più backoff.

859* `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS`: watchdog di blocco per i subagenti lanciati con `run_in_background`. Predefinito `600000`. Si ripristina su ogni evento di flusso; in caso di blocco interrompe il subagente, contrassegna l'attività come non riuscita e presenta l'errore al genitore con qualsiasi risultato parziale. Non si applica ai subagenti sincroni.

860* `CLAUDE_ENABLE_STREAM_WATCHDOG=1` con `CLAUDE_STREAM_IDLE_TIMEOUT_MS`: interrompe la richiesta quando le intestazioni sono arrivate ma il corpo della risposta smette di trasmettere. Disabilitato per impostazione predefinita. `CLAUDE_STREAM_IDLE_TIMEOUT_MS` predefinito a `300000` e viene bloccato a quel minimo. La richiesta interrotta passa attraverso il percorso di ripetizione normale.

861

839### `OutputFormat`862### `OutputFormat`

840 863

841Configurazione per la validazione dell'output strutturato. Passa questo come `dict` al campo `output_format` su `ClaudeAgentOptions`:864Configurazione per la validazione dell'output strutturato. Passa questo come `dict` al campo `output_format` su `ClaudeAgentOptions`:

1015 initialPrompt: str | None = None1038 initialPrompt: str | None = None

1016 maxTurns: int | None = None1039 maxTurns: int | None = None

1017 background: bool | None = None1040 background: bool | None = None

1018 effort: Literal["low", "medium", "high", "max"] | int | None = None1041 effort: Literal["low", "medium", "high", "xhigh", "max"] | int | None = None

1019 permissionMode: PermissionMode | None = None1042 permissionMode: PermissionMode | None = None

1020```1043```

1021 1044

1080class ToolPermissionContext:1103class ToolPermissionContext:

1081 signal: Any | None = None # Future: abort signal support1104 signal: Any | None = None # Future: abort signal support

1082 suggestions: list[PermissionUpdate] = field(default_factory=list)1105 suggestions: list[PermissionUpdate] = field(default_factory=list)

1106 blocked_path: str | None = None

1107 decision_reason: str | None = None

1108 title: str | None = None

1109 display_name: str | None = None

1110 description: str | None = None

1083```1111```

1084 1112

1086| :------------ | :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |1114| :---------------- | :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1088| `suggestions` | `list[PermissionUpdate]` | Suggerimenti di aggiornamento delle autorizzazioni dalla CLI. I prompt Bash includono un suggerimento con la destinazione `localSettings`, quindi restituirlo in `updated_permissions` scrive la regola in `.claude/settings.local.json` e persiste tra le sessioni. |1116| `suggestions` | `list[PermissionUpdate]` | Suggerimenti di aggiornamento delle autorizzazioni dalla CLI. I prompt Bash includono un suggerimento con la destinazione `localSettings`, quindi restituirlo in `updated_permissions` scrive la regola in `.claude/settings.local.json` e persiste tra le sessioni. |

1117| `blocked_path` | `str \| None` | Percorso del file che ha attivato la richiesta di autorizzazione, se applicabile. Ad esempio, quando un comando Bash tenta di accedere a un percorso al di fuori delle directory consentite |

1089 1122

1090### `PermissionResult`1123### `PermissionResult`

1091 1124

1466 is_error: bool1499 is_error: bool

1467 num_turns: int1500 num_turns: int

1468 session_id: str1501 session_id: str

1502 stop_reason: str | None = None

1469 total_cost_usd: float | None = None1503 total_cost_usd: float | None = None

1470 usage: dict[str, Any] | None = None1504 usage: dict[str, Any] | None = None

1471 result: str | None = None1505 result: str | None = None

1472 stop_reason: str | None = None

1473 structured_output: Any = None1506 structured_output: Any = None

1474 model_usage: dict[str, Any] | None = None1507 model_usage: dict[str, Any] | None = None

1508 permission_denials: list[Any] | None = None

1509 deferred_tool_use: DeferredToolUse | None = None

1510 errors: list[str] | None = None

1511 api_error_status: int | None = None

1512 uuid: str | None = None

1475```1513```

1476 1514

1477Il dict `usage` contiene le seguenti chiavi quando presenti:1515Il dict `usage` contiene le seguenti chiavi quando presenti:

2128```python theme={null}2166```python theme={null}

2129class PreToolUseHookSpecificOutput(TypedDict):2167class PreToolUseHookSpecificOutput(TypedDict):

2130 hookEventName: Literal["PreToolUse"]2168 hookEventName: Literal["PreToolUse"]

2131 permissionDecision: NotRequired[Literal["allow", "deny", "ask"]]2169 permissionDecision: NotRequired[Literal["allow", "deny", "ask", "defer"]]

2132 permissionDecisionReason: NotRequired[str]2170 permissionDecisionReason: NotRequired[str]

2133 updatedInput: NotRequired[dict[str, Any]]2171 updatedInput: NotRequired[dict[str, Any]]

2134 additionalContext: NotRequired[str]2172 additionalContext: NotRequired[str]

2137class PostToolUseHookSpecificOutput(TypedDict):2175class PostToolUseHookSpecificOutput(TypedDict):

2138 hookEventName: Literal["PostToolUse"]2176 hookEventName: Literal["PostToolUse"]

2139 additionalContext: NotRequired[str]2177 additionalContext: NotRequired[str]

2178 updatedToolOutput: NotRequired[Any]

2140 updatedMCPToolOutput: NotRequired[Any]2179 updatedMCPToolOutput: NotRequired[Any]

2141 2180

2142 2181

agent-sdk/typescript.md +56 −7

Details

8 8

9<script src="/components/typescript-sdk-type-links.js" defer />9<script src="/components/typescript-sdk-type-links.js" defer />

10 10

~~11<Note>~~

12 **Prova la nuova interfaccia V2 (anteprima):** Un'interfaccia semplificata con i pattern `send()` e `stream()` è ora disponibile, rendendo le conversazioni multi-turno più facili. [Scopri di più sull'anteprima TypeScript V2](/it/agent-sdk/typescript-v2-preview)

~~13</Note>~~

15## Installazione11## Installazione

16 12

17```bash theme={null}13```bash theme={null}

338| `env` | `Record<string, string \| undefined>` | `process.env` | Variabili di ambiente. Vedi [Variabili di ambiente](/it/env-vars) per le variabili che la CLI sottostante legge. Imposta `CLAUDE_AGENT_SDK_CLIENT_APP` per identificare la tua app nell'intestazione User-Agent |334| `env` | `Record<string, string \| undefined>` | `process.env` | Variabili di ambiente. Vedi [Variabili di ambiente](/it/env-vars) per le variabili che la CLI sottostante legge, e [Gestisci risposte API lente o bloccate](#handle-slow-or-stalled-api-responses) per le variabili relative ai timeout. Imposta `CLAUDE_AGENT_SDK_CLIENT_APP` per identificare la tua app nell'intestazione User-Agent |

341| `extraArgs` | `Record<string, string \| null>` | `{}` | Argomenti aggiuntivi |337| `extraArgs` | `Record<string, string \| null>` | `{}` | Argomenti aggiuntivi |

362| `sessionStore` | [`SessionStore`](/it/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Specchia i trascritti della sessione in un backend esterno in modo che qualsiasi host possa riprenderli. Vedi [Persisti le sessioni nell'archiviazione esterna](/it/agent-sdk/session-storage) |358| `sessionStore` | [`SessionStore`](/it/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Specchia i trascritti della sessione in un backend esterno in modo che qualsiasi host possa riprenderli. Vedi [Persisti le sessioni nell'archiviazione esterna](/it/agent-sdk/session-storage) |

359| `settings` | `string \| Settings` | `undefined` | Oggetto [impostazioni](/it/settings) inline o percorso a un file di impostazioni. Popola il livello flag-settings nell'[ordine di precedenza](/it/settings#settings-precedence). Cambia a runtime con [`applyFlagSettings()`](#applyflagsettings) |

363| `settingSources` | [`SettingSource`](#settingsource)`[]` | Impostazioni predefinite CLI (tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzioni Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Impostazioni predefinite CLI (tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzioni Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

364| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Funzione personalizzata per generare il processo Claude Code. Usa per eseguire Claude Code in VM, container o ambienti remoti |361| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Funzione personalizzata per generare il processo Claude Code. Usa per eseguire Claude Code in VM, container o ambienti remoti |

370| `tools` | `string[] \| { type: 'preset'; preset: 'claude_code' }` | `undefined` | Configurazione dei tool. Passa un array di nomi di tool o usa il preset per ottenere i tool predefiniti di Claude Code |367| `tools` | `string[] \| { type: 'preset'; preset: 'claude_code' }` | `undefined` | Configurazione dei tool. Passa un array di nomi di tool o usa il preset per ottenere i tool predefiniti di Claude Code |

371 368

369#### Gestisci risposte API lente o bloccate

370

371Il subprocess CLI legge diverse variabili di ambiente che controllano i timeout dell'API e il rilevamento dei blocchi. Passale attraverso l'opzione `env`:

372

373```typescript theme={null}

374const result = query({

375 prompt: "Analyze this code",

376 options: {

377 env: {

378 ...process.env,

379 API_TIMEOUT_MS: "120000",

380 CLAUDE_CODE_MAX_RETRIES: "2",

381 CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS: "120000",

382 },

383 },

384});

385```

386

387* `API_TIMEOUT_MS`: timeout per richiesta sul client Anthropic, in millisecondi. Predefinito `600000`. Si applica al loop principale e a tutti i subagenti.

388* `CLAUDE_CODE_MAX_RETRIES`: numero massimo di tentativi API. Predefinito `10`. Ogni tentativo ottiene la propria finestra `API_TIMEOUT_MS`, quindi il tempo wall case peggiore è approssimativamente `API_TIMEOUT_MS × (CLAUDE_CODE_MAX_RETRIES + 1)` più backoff.

389* `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS`: watchdog di blocco per i subagenti lanciati con `run_in_background`. Predefinito `600000`. Si ripristina su ogni evento di stream; al blocco interrompe il subagente, contrassegna l'attività come fallita e presenta l'errore al genitore con qualsiasi risultato parziale. Non si applica ai subagenti sincroni.

390* `CLAUDE_ENABLE_STREAM_WATCHDOG=1` con `CLAUDE_STREAM_IDLE_TIMEOUT_MS`: interrompe la richiesta quando le intestazioni sono arrivate ma il corpo della risposta smette di trasmettere. Disattivato per impostazione predefinita. `CLAUDE_STREAM_IDLE_TIMEOUT_MS` predefinito a `300000` ed è limitato a quel minimo. La richiesta interrotta passa attraverso il percorso di tentativo normale.

391

372### Oggetto `Query`392### Oggetto `Query`

373 393

374Interfaccia restituita dalla funzione `query()`.394Interfaccia restituita dalla funzione `query()`.

383 setPermissionMode(mode: PermissionMode): Promise<void>;403 setPermissionMode(mode: PermissionMode): Promise<void>;

384 setModel(model?: string): Promise<void>;404 setModel(model?: string): Promise<void>;

385 setMaxThinkingTokens(maxThinkingTokens: number | null): Promise<void>;405 setMaxThinkingTokens(maxThinkingTokens: number | null): Promise<void>;

406 applyFlagSettings(settings: { [K in keyof Settings]?: Settings[K] | null }): Promise<void>;

386 initializationResult(): Promise<SDKControlInitializeResponse>;407 initializationResult(): Promise<SDKControlInitializeResponse>;

387 supportedCommands(): Promise<SlashCommand[]>;408 supportedCommands(): Promise<SlashCommand[]>;

388 supportedModels(): Promise<ModelInfo[]>;409 supportedModels(): Promise<ModelInfo[]>;

431| `applyFlagSettings(settings)` | Unisce le impostazioni nel livello flag settings della sessione a runtime (disponibile solo in modalità input streaming). Vedi [`applyFlagSettings()`](#applyflagsettings) |

410| `initializationResult()` | Restituisce il risultato di inizializzazione completo inclusi i comandi supportati, i modelli, le informazioni dell'account e la configurazione dello stile di output |432| `initializationResult()` | Restituisce il risultato di inizializzazione completo inclusi i comandi supportati, i modelli, le informazioni dell'account e la configurazione dello stile di output |

421| `close()` | Chiudi la query e termina il processo sottostante. Termina forzatamente la query e pulisce tutte le risorse |443| `close()` | Chiudi la query e termina il processo sottostante. Termina forzatamente la query e pulisce tutte le risorse |

422 444

445#### `applyFlagSettings()`

446

447Cambia qualsiasi [impostazione](/it/settings) su una sessione in esecuzione senza riavviare la query. Usalo quando un'impostazione che non ha un setter dedicato deve cambiare a metà sessione, come irrigidire `permissions` dopo che l'agente legge input non attendibile. `setModel()` e `setPermissionMode()` sono setter dedicati per quelle due chiavi; `applyFlagSettings()` è la forma generale che accetta qualsiasi sottoinsieme delle chiavi di impostazioni, e passare `model` qui si comporta come `setModel()`.

448

449I valori vengono scritti nel livello flag-settings, lo stesso livello che l'opzione `settings` inline di `query()` popola all'avvio. Le impostazioni flag si trovano vicino alla parte superiore dell'[ordine di precedenza delle impostazioni](/it/settings#settings-precedence): sovrascrivono le impostazioni utente, progetto e locali, e solo le impostazioni della politica gestita possono sovrascriverle. Questo è lo stesso livello che la [sezione di precedenza in pagina](#settings-precedence) chiama opzioni programmatiche.

450

451Le chiamate successive eseguono un shallow-merge delle chiavi di livello superiore. Una seconda chiamata con `{ permissions: {...} }` sostituisce l'intero oggetto `permissions` dalla chiamata precedente piuttosto che eseguire un deep-merge in esso. Per cancellare una chiave dal livello flag e ricadere in fonti di precedenza inferiore, passa `null` per quella chiave. Passare `undefined` non ha effetto perché la serializzazione JSON lo elimina.

452

453Disponibile solo in modalità input streaming, lo stesso vincolo di `setModel()` e `setPermissionMode()`.

454

455L'esempio seguente cambia il modello attivo a metà sessione, quindi cancella l'override in modo che il modello ricada in qualsiasi cosa specifichino le impostazioni utente o progetto.

456

457```typescript theme={null}

458const q = query({ prompt: messageStream });

459

460// Sovrascrivi il modello per il resto della sessione

461await q.applyFlagSettings({ model: "claude-opus-4-6" });

462

463// Più tardi: cancella l'override e ricadi alle impostazioni di precedenza inferiore

464await q.applyFlagSettings({ model: null });

465```

466

467<Note>

468 `applyFlagSettings()` è solo TypeScript. L'SDK Python non espone un metodo equivalente.

469</Note>

470

423### `WarmQuery`471### `WarmQuery`

424 472

425Handle restituito da [`startup()`](#startup). Il subprocess è già generato e inizializzato, quindi chiamare `query()` su questo handle scrive il prompt direttamente in un processo pronto senza latenza di avvio.473Handle restituito da [`startup()`](#startup). Il subprocess è già generato e inizializzato, quindi chiamare `query()` su questo handle scrive il prompt direttamente in un processo pronto senza latenza di avvio.

6172. Impostazioni del progetto (`.claude/settings.json`)6652. Impostazioni del progetto (`.claude/settings.json`)

6183. Impostazioni dell'utente (`~/.claude/settings.json`)6663. Impostazioni dell'utente (`~/.claude/settings.json`)

619 667

620Le opzioni programmatiche come `agents` e `allowedTools` sovrascrivono le impostazioni del filesystem utente, progetto e locale. Le impostazioni della politica gestita hanno precedenza sulle opzioni programmatiche.668Le opzioni programmatiche come `agents`, `allowedTools` e `settings` sovrascrivono le impostazioni del filesystem utente, progetto e locale. Le impostazioni della politica gestita hanno precedenza sulle opzioni programmatiche.

621 669

622### `PermissionMode`670### `PermissionMode`

623 671

2443 2491

2444### `CallToolResult`2492### `CallToolResult`

2445 2493

2446Tipo di risultato del tool MCP (da `@modelcontextprotocol/sdk/types.js`).2494Tipo di risultato del tool MCP (da `@modelcontextprotocol/sdk/types.js`). `structuredContent` è un oggetto JSON che può essere restituito insieme a `content`, inclusi blocchi di immagini. Vedi [Restituisci dati strutturati](/it/agent-sdk/custom-tools#return-structured-data).

2447 2495

2448```typescript theme={null}2496```typescript theme={null}

2449type CallToolResult = {2497type CallToolResult = {

2451 type: "text" | "image" | "resource";2499 type: "text" | "image" | "resource";

2452 // I campi aggiuntivi variano in base al tipo2500 // I campi aggiuntivi variano in base al tipo

2453 }>;2501 }>;

2502 structuredContent?: Record<string, unknown>;

2454 isError?: boolean;2503 isError?: boolean;

2455};2504};

2456```2505```

amazon-bedrock.md +11 −1

Details

361 361

362```bash theme={null}362```bash theme={null}

363# Utilizzo dell'ID del profilo di inferenza363# Utilizzo dell'ID del profilo di inferenza

364export ANTHROPIC_MODEL='global.anthropic.claude-sonnet-4-6'364export ANTHROPIC_MODEL='us.anthropic.claude-sonnet-4-6'

365export ANTHROPIC_DEFAULT_HAIKU_MODEL='us.anthropic.claude-haiku-4-5-20251001-v1:0'365export ANTHROPIC_DEFAULT_HAIKU_MODEL='us.anthropic.claude-haiku-4-5-20251001-v1:0'

366 366

367# Utilizzo dell'ARN del profilo di inferenza dell'applicazione367# Utilizzo dell'ARN del profilo di inferenza dell'applicazione

462 462

463La [procedura guidata di configurazione](#sign-in-with-bedrock) offre un'opzione di contesto da 1M quando fissa i modelli. Per abilitarla per un modello fissato manualmente, aggiungi `[1m]` all'ID del modello. Vedi [Fissa i modelli per distribuzioni di terze parti](/it/model-config#pin-models-for-third-party-deployments) per i dettagli.463La [procedura guidata di configurazione](#sign-in-with-bedrock) offre un'opzione di contesto da 1M quando fissa i modelli. Per abilitarla per un modello fissato manualmente, aggiungi `[1m]` all'ID del modello. Vedi [Fissa i modelli per distribuzioni di terze parti](/it/model-config#pin-models-for-third-party-deployments) per i dettagli.

464 464

465## Livelli di servizio

466

467[I livelli di servizio di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html) ti consentono di scambiare il costo rispetto alla latenza. Imposta `ANTHROPIC_BEDROCK_SERVICE_TIER` su `default`, `flex` o `priority`:

468

469```bash theme={null}

470export ANTHROPIC_BEDROCK_SERVICE_TIER=priority

471```

472

473Claude Code invia questo come intestazione `X-Amzn-Bedrock-Service-Tier` su ogni richiesta. La disponibilità del livello varia in base al modello e alla regione. La capacità riservata utilizza un [ARN di throughput fornito](https://docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html) come ID del modello invece di questa impostazione.

474

465## AWS Guardrails475## AWS Guardrails

466 476

467[Amazon Bedrock Guardrails](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html) ti consente di implementare il filtro dei contenuti per Claude Code. Crea un Guardrail nella [console di Amazon Bedrock](https://console.aws.amazon.com/bedrock/), pubblica una versione, quindi aggiungi le intestazioni Guardrail al tuo [file di impostazioni](/it/settings). Abilita l'inferenza tra regioni sul tuo Guardrail se stai utilizzando profili di inferenza tra regioni.477[Amazon Bedrock Guardrails](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html) ti consente di implementare il filtro dei contenuti per Claude Code. Crea un Guardrail nella [console di Amazon Bedrock](https://console.aws.amazon.com/bedrock/), pubblica una versione, quindi aggiungi le intestazioni Guardrail al tuo [file di impostazioni](/it/settings). Abilita l'inferenza tra regioni sul tuo Guardrail se stai utilizzando profili di inferenza tra regioni.

authentication.md +6 −1

Details

113 113

114Claude Code gestisce in modo sicuro le Vostre credenziali di autenticazione:114Claude Code gestisce in modo sicuro le Vostre credenziali di autenticazione:

115 115

116* **Posizione di archiviazione**: su macOS, le credenziali sono archiviate nel Keychain macOS crittografato. Su Linux e Windows, le credenziali sono archiviate in `~/.claude/.credentials.json`, o sotto `$CLAUDE_CONFIG_DIR` se quella variabile è impostata. Su Linux, il file viene scritto con modalità `0600`; su Windows, eredita i controlli di accesso della directory del profilo utente.116* **Posizione di archiviazione**:

117 * Su macOS, le credenziali sono archiviate nel Keychain macOS crittografato.

118 * Su Linux, le credenziali sono archiviate in `~/.claude/.credentials.json` con modalità file `0600`.

119 * Su Windows, le credenziali sono archiviate in `%USERPROFILE%\.claude\.credentials.json` e ereditano i controlli di accesso della directory del profilo utente, che limita il file al Vostro account utente per impostazione predefinita.

120 * Se avete impostato la variabile di ambiente `CLAUDE_CONFIG_DIR` su Linux o Windows, il file `.credentials.json` si trova in quella directory.

121 * Claude Code gestisce `.credentials.json` attraverso `/login` e `/logout`. Per instradare le richieste attraverso un endpoint API personalizzato, impostate invece la variabile di ambiente [`ANTHROPIC_BASE_URL`](/it/env-vars).

117* **Tipi di autenticazione supportati**: credenziali Claude.ai, credenziali API Claude, Azure Auth, Bedrock Auth, e Vertex Auth.122* **Tipi di autenticazione supportati**: credenziali Claude.ai, credenziali API Claude, Azure Auth, Bedrock Auth, e Vertex Auth.

118* **Script di credenziali personalizzati**: l'impostazione [`apiKeyHelper`](/it/settings#available-settings) può essere configurata per eseguire uno script shell che restituisce una chiave API.123* **Script di credenziali personalizzati**: l'impostazione [`apiKeyHelper`](/it/settings#available-settings) può essere configurata per eseguire uno script shell che restituisce una chiave API.

119* **Intervalli di aggiornamento**: per impostazione predefinita, `apiKeyHelper` viene chiamato dopo 5 minuti o in risposta a HTTP 401. Impostate la variabile di ambiente `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` per intervalli di aggiornamento personalizzati.124* **Intervalli di aggiornamento**: per impostazione predefinita, `apiKeyHelper` viene chiamato dopo 5 minuti o in risposta a HTTP 401. Impostate la variabile di ambiente `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` per intervalli di aggiornamento personalizzati.

claude-code-on-the-web.md +42 −7

Details

113 113

114Ogni sessione cloud ha un URL di trascrizione su claude.ai e la sessione può leggere il suo ID dalla variabile di ambiente `CLAUDE_CODE_REMOTE_SESSION_ID`. Usa questo per mettere un link tracciabile nei corpi PR, nei messaggi di commit, nei post Slack o nei report generati in modo che un revisore possa aprire l'esecuzione che li ha prodotti.114Ogni sessione cloud ha un URL di trascrizione su claude.ai e la sessione può leggere il suo ID dalla variabile di ambiente `CLAUDE_CODE_REMOTE_SESSION_ID`. Usa questo per mettere un link tracciabile nei corpi PR, nei messaggi di commit, nei post Slack o nei report generati in modo che un revisore possa aprire l'esecuzione che li ha prodotti.

115 115

116Chiedi a Claude di costruire il link dalla variabile di ambiente. Il seguente comando stampa l'URL:116Il valore della variabile utilizza un prefisso `cse_`, mentre il percorso dell'URL di trascrizione utilizza lo stesso ID con un prefisso `session_`. Sostituisci il prefisso quando costruisci il link. Il seguente comando stampa l'URL:

117 117

118```bash theme={null}118```bash theme={null}

119echo "https://claude.ai/code/${CLAUDE_CODE_REMOTE_SESSION_ID}"119echo "https://claude.ai/code/${CLAUDE_CODE_REMOTE_SESSION_ID/#cse_/session_}"

120```120```

121 121

122### Esegui test, avvia servizi e aggiungi pacchetti122### Esegui test, avvia servizi e aggiungi pacchetti

156| Azione | Come |156| Azione | Come |

157| :------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |157| :------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

158| Aggiungi un ambiente | Seleziona l'ambiente attuale per aprire il selettore, quindi seleziona **Aggiungi ambiente**. La finestra di dialogo include nome, livello di accesso alla rete, variabili di ambiente e script di configurazione. |158| Aggiungi un ambiente | Seleziona l'ambiente attuale per aprire il selettore, quindi seleziona **Aggiungi ambiente**. La finestra di dialogo include nome, livello di accesso alla rete, variabili di ambiente e script di configurazione. |

159| Modifica un ambiente | Seleziona l'icona delle impostazioni a destra del nome dell'ambiente. |159| Modifica un ambiente | Seleziona l'icona cloud che mostra il nome dell'ambiente attuale per aprire il selettore, passa il mouse su un ambiente e fai clic sull'icona delle impostazioni che appare a destra. |

160| Archivia un ambiente | Apri l'ambiente per la modifica e seleziona **Archivia**. Gli ambienti archiviati sono nascosti dal selettore ma le sessioni esistenti continuano a essere eseguite. |160| Archivia un ambiente | Apri l'ambiente per la modifica e seleziona **Archivia**. Gli ambienti archiviati sono nascosti dal selettore ma le sessioni esistenti continuano a essere eseguite. |

161| Imposta il predefinito per `--remote` | Esegui `/remote-env` nel tuo terminale. Se hai un singolo ambiente, questo comando mostra la tua configurazione attuale. `/remote-env` seleziona solo il predefinito; aggiungi, modifica e archivia gli ambienti dall'interfaccia web. |161| Imposta il predefinito per `--remote` | Esegui `/remote-env` nel tuo terminale. Se hai un singolo ambiente, questo comando mostra la tua configurazione attuale. `/remote-env` seleziona solo il predefinito; aggiungi, modifica e archivia gli ambienti dall'interfaccia web. |

162 162

174 174

175Gli script vengono eseguiti come root su Ubuntu 24.04, quindi `apt install` e la maggior parte dei gestori di pacchetti di linguaggio funzionano.175Gli script vengono eseguiti come root su Ubuntu 24.04, quindi `apt install` e la maggior parte dei gestori di pacchetti di linguaggio funzionano.

176 176

177Per aggiungere uno script di configurazione, apri la finestra di dialogo delle impostazioni dell'ambiente e inserisci il tuo script nel campo **Script di configurazione**.177Per aggiungere uno script di configurazione, apri la finestra di dialogo delle impostazioni dell'ambiente e inserisci il tuo script nel campo **Setup script**.

178 178

179Questo esempio installa la CLI `gh`, che non è preinstallata:179Questo esempio installa la CLI `gh`, che non è preinstallata:

180 180

185 185

186Se lo script esce con un codice diverso da zero, la sessione non si avvia. Aggiungi `|| true` ai comandi non critici per evitare di bloccare la sessione su un'installazione intermittente fallita.186Se lo script esce con un codice diverso da zero, la sessione non si avvia. Aggiungi `|| true` ai comandi non critici per evitare di bloccare la sessione su un'installazione intermittente fallita.

187 187

188Mantieni il tempo di esecuzione totale dello script sotto circa cinque minuti in modo che la [cache dell'ambiente](#environment-caching) possa essere costruita. Esegui installazioni indipendenti in parallelo con `&` e `wait`. Se un singolo download non rientra nel limite di cinque minuti, spostalo in un [hook SessionStart](#setup-scripts-vs-sessionstart-hooks) che lo avvia in background.

189

188<Note>190<Note>

189 Gli script di configurazione che installano pacchetti hanno bisogno di accesso alla rete per raggiungere i registri. L'accesso alla rete predefinito **Trusted** consente connessioni ai [domini di pacchetti comuni](#default-allowed-domains) inclusi npm, PyPI, RubyGems e crates.io. Gli script non riusciranno a installare pacchetti se il tuo ambiente usa l'accesso alla rete **None**.191 Gli script di configurazione che installano pacchetti hanno bisogno di accesso alla rete per raggiungere i registri. L'accesso alla rete predefinito **Trusted** consente connessioni ai [domini di pacchetti comuni](#default-allowed-domains) inclusi npm, PyPI, RubyGems e crates.io. Gli script non riusciranno a installare pacchetti se il tuo ambiente usa l'accesso alla rete **None**.

190</Note>192</Note>

265 267

266L'accesso alla rete controlla le connessioni in uscita dall'ambiente cloud. Ogni ambiente specifica un livello di accesso e puoi estenderlo con domini personalizzati consentiti. Il predefinito è **Trusted**, che consente i registri di pacchetti e altri [domini consentiti](#default-allowed-domains).268L'accesso alla rete controlla le connessioni in uscita dall'ambiente cloud. Ogni ambiente specifica un livello di accesso e puoi estenderlo con domini personalizzati consentiti. Il predefinito è **Trusted**, che consente i registri di pacchetti e altri [domini consentiti](#default-allowed-domains).

267 269

270Per modificare l'accesso alla rete di un ambiente, [aprilo per la modifica](#configure-your-environment) e usa il selettore **Network access** nella finestra di dialogo. Non esiste una pagina Ambienti separata. L'icona cloud appare ovunque tu avvii una sessione cloud o configuri una [routine](/it/routines#environments-and-network-access).

271

272<Note>

273 Il traffico del connettore MCP viene instradato attraverso i server di Anthropic, quindi i connettori che abiliti su una sessione o routine funzionano senza aggiungere i loro host ai **Domini consentiti**. I connettori sono configurati per sessione o per routine; rimuovi quelli che non hai bisogno di limitare quali strumenti Claude può raggiungere. Questo si basa sullo stesso canale legato ad Anthropic notato in [Sicurezza e isolamento](#security-and-isolation).

274</Note>

275

268### Livelli di accesso276### Livelli di accesso

269 277

270Scegli un livello di accesso quando crei o modifichi un ambiente:278Scegli un livello di accesso quando crei o modifichi un ambiente:

280 288

281### Consenti domini specifici289### Consenti domini specifici

282 290

283Per consentire domini che non sono nell'elenco Trusted, seleziona **Custom** nelle impostazioni di accesso alla rete dell'ambiente. Appare un campo **Domini consentiti**. Inserisci un dominio per riga:291Per consentire domini che non sono nell'elenco Trusted, seleziona **Custom** nelle impostazioni di accesso alla rete dell'ambiente. Appare un campo **Allowed domains**. Inserisci un dominio per riga:

284 292

285```text theme={null}293```text theme={null}

286api.example.com294api.example.com

288registry.example.com296registry.example.com

289```297```

290 298

291Usa `*.` per la corrispondenza dei sottodomini con caratteri jolly. Seleziona **Includi anche l'elenco predefinito di gestori di pacchetti comuni** per mantenere i [domini Trusted](#default-allowed-domains) insieme alle tue voci personalizzate, o lascialo deselezionato per consentire solo quello che elenchi.299Usa `*.` per la corrispondenza dei sottodomini con caratteri jolly. Seleziona **Also include default list of common package managers** per mantenere i [domini Trusted](#default-allowed-domains) insieme alle tue voci personalizzate, o lascialo deselezionato per consentire solo quello che elenchi.

292 300

293### Proxy GitHub301### Proxy GitHub

294 302

640* **Usando `--teleport`**: dalla riga di comando, esegui `claude --teleport` per un selettore di sessione interattivo, o `claude --teleport <session-id>` per riprendere una sessione specifica direttamente. Se hai modifiche non sottoposte a commit, ti verrà chiesto di archiviarle prima.648* **Usando `--teleport`**: dalla riga di comando, esegui `claude --teleport` per un selettore di sessione interattivo, o `claude --teleport <session-id>` per riprendere una sessione specifica direttamente. Se hai modifiche non sottoposte a commit, ti verrà chiesto di archiviarle prima.

641* **Usando `/teleport`**: all'interno di una sessione CLI esistente, esegui `/teleport` (o `/tp`) per aprire lo stesso selettore di sessione senza riavviare Claude Code.649* **Usando `/teleport`**: all'interno di una sessione CLI esistente, esegui `/teleport` (o `/tp`) per aprire lo stesso selettore di sessione senza riavviare Claude Code.

642* **Da `/tasks`**: esegui `/tasks` per vedere le tue sessioni in background, quindi premi `t` per teletrasportarti in una650* **Da `/tasks`**: esegui `/tasks` per vedere le tue sessioni in background, quindi premi `t` per teletrasportarti in una

643* **Dall'interfaccia web**: seleziona **Apri in CLI** per copiare un comando che puoi incollare nel tuo terminale651* **Dall'interfaccia web**: seleziona **Open in CLI** per copiare un comando che puoi incollare nel tuo terminale

644 652

645Quando teletrasporti una sessione, Claude verifica che sei nel repository corretto, recupera e controlla il ramo dalla sessione cloud e carica la cronologia completa della conversazione nel tuo terminale.653Quando teletrasporti una sessione, Claude verifica che sei nel repository corretto, recupera e controlla il ramo dalla sessione cloud e carica la cronologia completa della conversazione nel tuo terminale.

646 654

754* **Protezione delle credenziali**: le credenziali sensibili come le credenziali git o le chiavi di firma non sono mai all'interno della sandbox con Claude Code. L'autenticazione viene gestita tramite un proxy sicuro utilizzando credenziali con ambito.762* **Protezione delle credenziali**: le credenziali sensibili come le credenziali git o le chiavi di firma non sono mai all'interno della sandbox con Claude Code. L'autenticazione viene gestita tramite un proxy sicuro utilizzando credenziali con ambito.

755* **Analisi sicura**: il codice viene analizzato e modificato all'interno di VM isolate prima di creare PR763* **Analisi sicura**: il codice viene analizzato e modificato all'interno di VM isolate prima di creare PR

756 764

765## Risoluzione dei problemi

766

767Per gli errori API di runtime che appaiono nella conversazione come `API Error: 500`, `529 Overloaded`, `429` o `Prompt is too long`, vedi il [riferimento degli errori](/it/errors). Questi errori e le loro correzioni sono condivisi con la CLI e l'app Desktop. Le sezioni seguenti coprono i problemi specifici delle sessioni cloud.

768

769### Creazione della sessione non riuscita

770

771Se una nuova sessione non si avvia con `Session creation failed` o si blocca al provisioning, Claude Code non ha potuto allocare un ambiente cloud.

772

773* Controlla [status.claude.com](https://status.claude.com) per gli incidenti delle sessioni cloud

774* Riprova dopo un minuto, poiché la capacità viene fornita su richiesta

775* Conferma che il tuo repository sia raggiungibile. I repository privati richiedono l'app GitHub installata con accesso a quel repository, o un token `gh` sincronizzato tramite `/web-setup`. Vedi [Opzioni di autenticazione GitHub](#github-authentication-options).

776

777### Sessione Remote Control scaduta o accesso negato

778

779`--teleport` si connette attraverso la stessa infrastruttura della sessione Remote Control che le sessioni cloud utilizzano, quindi gli errori di autenticazione e scadenza della sessione si presentano con la terminologia Remote Control. Potresti vedere `Remote Control session has expired` o `Access denied`. Il token di connessione è di breve durata e limitato al tuo account.

780

781* Esegui `/login` localmente per aggiornare le tue credenziali, quindi riconnettiti

782* Conferma che sei connesso allo stesso account che possiede la sessione

783* Se vedi `Remote Control may not be available for this organization`, il tuo amministratore non ha abilitato le sessioni remote per il tuo piano

784

785### Ambiente scaduto

786

787Le sessioni cloud si fermano dopo un periodo di inattività e l'ambiente sottostante viene recuperato. Da un terminale locale, questo si presenta come `Could not resume session ... its environment has expired. Creating a fresh session instead.` Sul web, la sessione è contrassegnata come scaduta nell'elenco delle sessioni.

788

789Riapri la sessione da [claude.ai/code](https://claude.ai/code) per fornire un ambiente fresco con la cronologia della conversazione ripristinata.

790

757## Limitazioni791## Limitazioni

758 792

759Prima di fare affidamento sulle sessioni cloud per un flusso di lavoro, tieni conto di questi vincoli:793Prima di fare affidamento sulle sessioni cloud per un flusso di lavoro, tieni conto di questi vincoli:

761* **Limiti di velocità**: Claude Code sul web condivide i limiti di velocità con tutti gli altri utilizzi di Claude e Claude Code all'interno del tuo account. L'esecuzione di più attività in parallelo consumerà più limiti di velocità proporzionalmente. Non esiste alcun addebito di calcolo separato per la VM cloud.795* **Limiti di velocità**: Claude Code sul web condivide i limiti di velocità con tutti gli altri utilizzi di Claude e Claude Code all'interno del tuo account. L'esecuzione di più attività in parallelo consumerà più limiti di velocità proporzionalmente. Non esiste alcun addebito di calcolo separato per la VM cloud.

762* **Autenticazione del repository**: puoi spostare le sessioni da web a locale solo quando sei autenticato allo stesso account796* **Autenticazione del repository**: puoi spostare le sessioni da web a locale solo quando sei autenticato allo stesso account

763* **Restrizioni della piattaforma**: il clonaggio del repository e la creazione di pull request richiedono GitHub. Le istanze self-hosted di [GitHub Enterprise Server](/it/github-enterprise-server) sono supportate per i piani Team e Enterprise. GitLab, Bitbucket e altri repository non GitHub possono essere inviati alle sessioni cloud come [bundle locale](#send-local-repositories-without-github), ma la sessione non può eseguire il push dei risultati di nuovo al remoto797* **Restrizioni della piattaforma**: il clonaggio del repository e la creazione di pull request richiedono GitHub. Le istanze self-hosted di [GitHub Enterprise Server](/it/github-enterprise-server) sono supportate per i piani Team e Enterprise. GitLab, Bitbucket e altri repository non GitHub possono essere inviati alle sessioni cloud come [bundle locale](#send-local-repositories-without-github), ma la sessione non può eseguire il push dei risultati di nuovo al remoto

798* **Elenco IP consentiti dell'organizzazione**: le sessioni cloud chiamano l'API Anthropic dall'infrastruttura gestita da Anthropic, non dalla tua rete. Se la tua organizzazione ha [IP allowlisting](https://support.claude.com/en/articles/13200993-restrict-access-to-claude-with-ip-allowlisting) abilitato, ogni sessione cloud fallisce con un errore di autenticazione. Lo stesso vale per [Code Review](/it/code-review) e [Routines](/it/routines). Contatta il [supporto Anthropic](https://support.claude.com/) per esentare i servizi ospitati da Anthropic dall'elenco IP consentiti della tua organizzazione.

764 799

765## Risorse correlate800## Risorse correlate

766 801

cli-reference.md +11 −10

Details

40Personalizza il comportamento di Claude Code con questi flag da riga di comando. `claude --help` non elenca ogni flag, quindi l'assenza di un flag da `--help` non significa che non sia disponibile.40Personalizza il comportamento di Claude Code con questi flag da riga di comando. `claude --help` non elenca ogni flag, quindi l'assenza di un flag da `--help` non significa che non sia disponibile.

41 41

43| :---------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- |43| :---------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- |

44| `--add-dir` | Aggiungi directory di lavoro aggiuntive per Claude per leggere e modificare file. Concede l'accesso ai file; la maggior parte della configurazione `.claude/` [non viene scoperta](/it/permissions#additional-directories-grant-file-access-not-configuration) da queste directory. Convalida che ogni percorso esista come directory | `claude --add-dir ../apps ../lib` |44| `--add-dir` | Aggiungi directory di lavoro aggiuntive per Claude per leggere e modificare file. Concede l'accesso ai file; la maggior parte della configurazione `.claude/` [non viene scoperta](/it/permissions#additional-directories-grant-file-access-not-configuration) da queste directory. Convalida che ogni percorso esista come directory. Per persistere queste directory tra le sessioni, imposta [`permissions.additionalDirectories`](/it/settings#permission-settings) nelle impostazioni | `claude --add-dir ../apps ../lib` |

46| `--agents` | Definisci subagents personalizzati dinamicamente tramite JSON. Utilizza gli stessi nomi di campo del [frontmatter](/it/sub-agents#supported-frontmatter-fields) dei subagents, più un campo `prompt` per le istruzioni dell'agent | `claude --agents '{"reviewer":{"description":"Reviews code","prompt":"You are a code reviewer"}}'` |46| `--agents` | Definisci subagents personalizzati dinamicamente tramite JSON. Utilizza gli stessi nomi di campo del [frontmatter](/it/sub-agents#supported-frontmatter-fields) dei subagents, più un campo `prompt` per le istruzioni dell'agent | `claude --agents '{"reviewer":{"description":"Reviews code","prompt":"You are a code reviewer"}}'` |

47| `--allow-dangerously-skip-permissions` | Aggiungi `bypassPermissions` al ciclo della modalità `Shift+Tab` senza iniziare in essa. Ti consente di iniziare in una modalità diversa come `plan` e passare a `bypassPermissions` in seguito. Vedi [modalità di autorizzazione](/it/permission-modes#skip-all-checks-with-bypasspermissions-mode) | `claude --permission-mode plan --allow-dangerously-skip-permissions` |47| `--allow-dangerously-skip-permissions` | Aggiungi `bypassPermissions` al ciclo della modalità `Shift+Tab` senza iniziare in essa. Ti consente di iniziare in una modalità diversa come `plan` e passare a `bypassPermissions` in seguito. Vedi [modalità di autorizzazione](/it/permission-modes#skip-all-checks-with-bypasspermissions-mode) | `claude --permission-mode plan --allow-dangerously-skip-permissions` |

59| `--debug-file <path>` | Scrivi i log di debug in un percorso file specifico. Abilita implicitamente la modalità debug. Ha la precedenza su `CLAUDE_CODE_DEBUG_LOGS_DIR` | `claude --debug-file /tmp/claude-debug.log` |59| `--debug-file <path>` | Scrivi i log di debug in un percorso file specifico. Abilita implicitamente la modalità debug. Ha la precedenza su `CLAUDE_CODE_DEBUG_LOGS_DIR` | `claude --debug-file /tmp/claude-debug.log` |

62| `--effort` | Imposta il [livello di sforzo](/it/model-config#adjust-effort-level) per la sessione corrente. Opzioni: `low`, `medium`, `high`, `xhigh`, `max`; i livelli disponibili dipendono dal modello. Limitato alla sessione e non persiste nelle impostazioni | `claude --effort high` |62| `--effort` | Imposta il [livello di sforzo](/it/model-config#adjust-effort-level) per la sessione corrente. Opzioni: `low`, `medium`, `high`, `xhigh`, `max`; i livelli disponibili dipendono dal modello. Sostituisce l'impostazione [`effortLevel`](/it/settings#available-settings) per questa sessione e non persiste | `claude --effort high` |

63| `--enable-auto-mode` | {/* max-version: 2.1.110 */}Rimosso in v2.1.111. Auto mode è ora nel ciclo `Shift+Tab` per impostazione predefinita; usa `--permission-mode auto` per iniziare in esso | `claude --permission-mode auto` |63| `--enable-auto-mode` | {/* max-version: 2.1.110 */}Rimosso in v2.1.111. Auto mode è ora nel ciclo `Shift+Tab` per impostazione predefinita; usa `--permission-mode auto` per iniziare in esso | `claude --permission-mode auto` |

64| `--exclude-dynamic-system-prompt-sections` | Sposta le sezioni per macchina dal prompt di sistema (directory di lavoro, informazioni sull'ambiente, percorsi di memoria, stato git) nel primo messaggio dell'utente. Migliora il riutilizzo della prompt-cache tra diversi utenti e macchine che eseguono lo stesso compito. Si applica solo con il prompt di sistema predefinito; ignorato quando `--system-prompt` o `--system-prompt-file` è impostato. Usa con `-p` per carichi di lavoro con script e multi-utente | `claude -p --exclude-dynamic-system-prompt-sections "query"` |64| `--exclude-dynamic-system-prompt-sections` | Sposta le sezioni per macchina dal prompt di sistema (directory di lavoro, informazioni sull'ambiente, percorsi di memoria, stato git) nel primo messaggio dell'utente. Migliora il riutilizzo della prompt-cache tra diversi utenti e macchine che eseguono lo stesso compito. Si applica solo con il prompt di sistema predefinito; ignorato quando `--system-prompt` o `--system-prompt-file` è impostato. Usa con `-p` per carichi di lavoro con script e multi-utente | `claude -p --exclude-dynamic-system-prompt-sections "query"` |

65| `--fallback-model` | Abilita il fallback automatico al modello specificato quando il modello predefinito è sovraccarico (solo modalità print) | `claude -p --fallback-model sonnet "query"` |65| `--fallback-model` | Abilita il fallback automatico al modello specificato quando il modello predefinito è sovraccarico (solo modalità print) | `claude -p --fallback-model sonnet "query"` |

77| `--max-turns` | Limita il numero di turni agentici (solo modalità print). Esce con un errore quando il limite viene raggiunto. Nessun limite per impostazione predefinita | `claude -p --max-turns 3 "query"` |77| `--max-turns` | Limita il numero di turni agentici (solo modalità print). Esce con un errore quando il limite viene raggiunto. Nessun limite per impostazione predefinita | `claude -p --max-turns 3 "query"` |

79| `--model` | Imposta il modello per la sessione corrente con un alias per il modello più recente (`sonnet` o `opus`) o il nome completo di un modello | `claude --model claude-sonnet-4-6` |79| `--model` | Imposta il modello per la sessione corrente con un alias per il modello più recente (`sonnet` o `opus`) o il nome completo di un modello. Sostituisce l'impostazione [`model`](/it/settings#available-settings) e [`ANTHROPIC_MODEL`](/it/model-config#environment-variables) | `claude --model claude-sonnet-4-6` |

80| `--name`, `-n` | Imposta un nome visualizzato per la sessione, mostrato in `/resume` e nel titolo del terminale. Puoi riprendere una sessione denominata con `claude --resume <name>`. <br /><br />[`/rename`](/it/commands) cambia il nome durante la sessione e lo mostra anche nella barra del prompt | `claude -n "my-feature-work"` |80| `--name`, `-n` | Imposta un nome visualizzato per la sessione, mostrato in `/resume` e nel titolo del terminale. Puoi riprendere una sessione denominata con `claude --resume <name>`. <br /><br />[`/rename`](/it/commands) cambia il nome durante la sessione e lo mostra anche nella barra del prompt | `claude -n "my-feature-work"` |

82| `--no-session-persistence` | Disabilita la persistenza della sessione in modo che le sessioni non vengano salvate su disco e non possano essere riprese (solo modalità print) | `claude -p --no-session-persistence "query"` |82| `--no-session-persistence` | Disabilita la persistenza della sessione in modo che le sessioni non vengano salvate su disco e non possano essere riprese. Solo modalità print. La variabile di ambiente [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/it/env-vars) fa lo stesso in qualsiasi modalità | `claude -p --no-session-persistence "query"` |

84| `--permission-mode` | Inizia in una [modalità di autorizzazione](/it/permission-modes) specificata. Accetta `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` o `bypassPermissions`. Sostituisce `defaultMode` dai file di impostazioni | `claude --permission-mode plan` |84| `--permission-mode` | Inizia in una [modalità di autorizzazione](/it/permission-modes) specificata. Accetta `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` o `bypassPermissions`. Sostituisce `defaultMode` dai file di impostazioni | `claude --permission-mode plan` |

85| `--permission-prompt-tool` | Specifica uno strumento MCP per gestire i prompt di autorizzazione in modalità non interattiva | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |85| `--permission-prompt-tool` | Specifica uno strumento MCP per gestire i prompt di autorizzazione in modalità non interattiva | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |

86| `--plugin-dir` | Carica plugin da una directory per questa sessione solo. Ogni flag accetta un percorso. Ripeti il flag per più directory: `--plugin-dir A --plugin-dir B` | `claude --plugin-dir ./my-plugins` |86| `--plugin-dir` | Carica un plugin da una directory o da un archivio `.zip` per questa sessione solo. Ogni flag accetta un percorso. Ripeti il flag per più plugin: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |

87| `--plugin-url` | Recupera un archivio plugin `.zip` da un URL per questa sessione solo. Ogni flag accetta un URL. Ripeti il flag per più plugin | `claude --plugin-url https://example.com/plugin.zip` |

87| `--print`, `-p` | Stampa la risposta senza modalità interattiva (vedi [documentazione Agent SDK](/it/agent-sdk/overview) per i dettagli di utilizzo programmatico) | `claude -p "query"` |88| `--print`, `-p` | Stampa la risposta senza modalità interattiva (vedi [documentazione Agent SDK](/it/agent-sdk/overview) per i dettagli di utilizzo programmatico) | `claude -p "query"` |

89| `--remote-control`, `--rc` | Avvia una sessione interattiva con [Remote Control](/it/remote-control#start-a-remote-control-session) abilitato in modo da poterla controllare anche da claude.ai o dall'app Claude. Facoltativamente passa un nome per la sessione | `claude --remote-control "My Project"` |90| `--remote-control`, `--rc` | Avvia una sessione interattiva con [Remote Control](/it/remote-control#start-a-remote-control-session) abilitato in modo da poterla controllare anche da claude.ai o dall'app Claude. Facoltativamente passa un nome per la sessione | `claude --remote-control "My Project"` |

92| `--resume`, `-r` | Riprendi una sessione specifica per ID o nome, o mostra un selettore interattivo per scegliere una sessione. Include sessioni che hanno aggiunto questa directory con `/add-dir` | `claude --resume auth-refactor` |93| `--resume`, `-r` | Riprendi una sessione specifica per ID o nome, o mostra un selettore interattivo per scegliere una sessione. Include sessioni che hanno aggiunto questa directory con `/add-dir` | `claude --resume auth-refactor` |

95| `--settings` | Percorso di un file JSON di impostazioni o una stringa JSON da cui caricare impostazioni aggiuntive | `claude --settings ./settings.json` |96| `--settings` | Percorso di un file JSON di impostazioni o una stringa JSON inline. I valori che imposti qui sostituiscono le stesse chiavi nei tuoi file `settings.json` per questa sessione. Le chiavi che ometti mantengono i loro valori basati su file. Vedi [precedenza delle impostazioni](/it/settings#settings-precedence) | `claude --settings ./settings.json` |

100| `--teammate-mode` | Imposta come i compagni di squadra del [team di agent](/it/agent-teams) vengono visualizzati: `auto` (predefinito), `in-process` o `tmux`. Vedi [Scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `claude --teammate-mode in-process` |101| `--teammate-mode` | Imposta come i compagni di squadra del [team di agent](/it/agent-teams) vengono visualizzati: `auto` (predefinito), `in-process` o `tmux`. Sostituisce l'impostazione [`teammateMode`](/it/settings#available-settings) per questa sessione. Vedi [Scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `claude --teammate-mode in-process` |

101| `--tmux` | Crea una sessione tmux per il worktree. Richiede `--worktree`. Utilizza i riquadri nativi di iTerm2 quando disponibili; passa `--tmux=classic` per tmux tradizionale | `claude -w feature-auth --tmux` |102| `--tmux` | Crea una sessione tmux per il worktree. Richiede `--worktree`. Utilizza i riquadri nativi di iTerm2 quando disponibili; passa `--tmux=classic` per tmux tradizionale | `claude -w feature-auth --tmux` |

102| `--tools` | Limita quali strumenti integrati Claude può utilizzare. Usa `""` per disabilitare tutti, `"default"` per tutti, o nomi di strumenti come `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |103| `--tools` | Limita quali strumenti integrati Claude può utilizzare. Usa `""` per disabilitare tutti, `"default"` per tutti, o nomi di strumenti come `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |

105| `--worktree`, `-w` | Avvia Claude in un [git worktree](/it/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) isolato in `<repo>/.claude/worktrees/<name>`. Se non viene fornito alcun nome, uno viene generato automaticamente | `claude -w feature-auth` |106| `--worktree`, `-w` | Avvia Claude in un [git worktree](/it/worktrees) isolato in `<repo>/.claude/worktrees/<name>`. Se non viene fornito alcun nome, uno viene generato automaticamente | `claude -w feature-auth` |

106 107

107### Flag del prompt di sistema108### Flag del prompt di sistema

108 109

commands.md +7 −5

Details

10 10

11Digita `/` per visualizzare ogni comando disponibile per te, oppure digita `/` seguito da lettere per filtrare.11Digita `/` per visualizzare ogni comando disponibile per te, oppure digita `/` seguito da lettere per filtrare.

12 12

13Un comando viene riconosciuto solo all'inizio del tuo messaggio. Il testo che segue il nome del comando viene passato ad esso come argomenti.

13La tabella sottostante elenca tutti i comandi inclusi in Claude Code. Le voci contrassegnate come **[Skill](/it/skills#bundled-skills)** sono skill integrate. Utilizzano lo stesso meccanismo delle skill che scrivi tu stesso: un prompt consegnato a Claude, che Claude può anche invocare automaticamente quando rilevante. Tutto il resto è un comando integrato il cui comportamento è codificato nella CLI. Per aggiungere i tuoi comandi, vedi [skills](/it/skills).15La tabella sottostante elenca tutti i comandi inclusi in Claude Code. Le voci contrassegnate come **[Skill](/it/skills#bundled-skills)** sono skill integrate. Utilizzano lo stesso meccanismo delle skill che scrivi tu stesso: un prompt consegnato a Claude, che Claude può anche invocare automaticamente quando rilevante. Tutto il resto è un comando integrato il cui comportamento è codificato nella CLI. Per aggiungere i tuoi comandi, vedi [skills](/it/skills).

14 16

15Non ogni comando appare per ogni utente. La disponibilità dipende dalla tua piattaforma, dal piano e dall'ambiente. Ad esempio, `/desktop` appare solo su macOS e Windows, e `/upgrade` appare solo sui piani Pro e Max.17Non ogni comando appare per ogni utente. La disponibilità dipende dalla tua piattaforma, dal piano e dall'ambiente. Ad esempio, `/desktop` appare solo su macOS e Windows, e `/upgrade` appare solo sui piani Pro e Max.

21| `/add-dir <path>` | Aggiungi una directory di lavoro per l'accesso ai file durante la sessione corrente. La maggior parte della configurazione `.claude/` [non viene rilevata](/it/permissions#additional-directories-grant-file-access-not-configuration) dalla directory aggiunta. Puoi successivamente riprendere la sessione dalla directory aggiunta con `--continue` o `--resume` |23| `/add-dir <path>` | Aggiungi una directory di lavoro per l'accesso ai file durante la sessione corrente. La maggior parte della configurazione `.claude/` [non viene rilevata](/it/permissions#additional-directories-grant-file-access-not-configuration) dalla directory aggiunta. Puoi successivamente riprendere la sessione dalla directory aggiunta con `--continue` o `--resume` |

23| `/autofix-pr [prompt]` | Avvia una sessione [Claude Code sul web](/it/claude-code-on-the-web#auto-fix-pull-requests) che monitora il PR del ramo corrente e invia correzioni quando la CI fallisce o i revisori lasciano commenti. Rileva il PR aperto dal ramo in cui sei posizionato con `gh pr view`; per monitorare un PR diverso, prima controlla il suo ramo. Per impostazione predefinita, la sessione remota viene istruita a correggere ogni fallimento della CI e commento di revisione; passa un prompt per darle istruzioni diverse, ad esempio `/autofix-pr only fix lint and type errors`. Richiede la CLI `gh` e l'accesso a [Claude Code sul web](/it/claude-code-on-the-web#who-can-use-claude-code-on-the-web) |25| `/autofix-pr [prompt]` | Avvia una sessione [Claude Code sul web](/it/claude-code-on-the-web#auto-fix-pull-requests) che monitora il PR del ramo corrente e invia correzioni quando la CI fallisce o i revisori lasciano commenti. Rileva il PR aperto dal ramo in cui sei posizionato con `gh pr view`; per monitorare un PR diverso, prima controlla il suo ramo. Per impostazione predefinita, la sessione remota viene istruita a correggere ogni fallimento della CI e commento di revisione; passa un prompt per darle istruzioni diverse, ad esempio `/autofix-pr only fix lint and type errors`. Richiede la CLI `gh` e l'accesso a [Claude Code sul web](/it/claude-code-on-the-web#who-can-use-claude-code-on-the-web) |

24| `/batch <instruction>` | **[Skill](/it/skills#bundled-skills).** Orchestra modifiche su larga scala in un codebase in parallelo. Ricerca il codebase, scompone il lavoro in 5-30 unità indipendenti e presenta un piano. Una volta approvato, avvia un agente in background per unità in un [git worktree](/it/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) isolato. Ogni agente implementa la sua unità, esegue i test e apre una pull request. Richiede un repository git. Esempio: `/batch migrate src/ from Solid to React` |26| `/batch <instruction>` | **[Skill](/it/skills#bundled-skills).** Orchestra modifiche su larga scala in un codebase in parallelo. Ricerca il codebase, scompone il lavoro in 5-30 unità indipendenti e presenta un piano. Una volta approvato, avvia un agente in background per unità in un [git worktree](/it/worktrees) isolato. Ogni agente implementa la sua unità, esegue i test e apre una pull request. Richiede un repository git. Esempio: `/batch migrate src/ from Solid to React` |

25| `/branch [name]` | Crea un ramo della conversazione corrente a questo punto. Ti sposta nel ramo e preserva l'originale, al quale puoi tornare con `/resume`. Alias: `/fork`. Quando [`CLAUDE_CODE_FORK_SUBAGENT`](/it/env-vars) è impostato, `/fork` invece avvia un [subagent con fork](/it/sub-agents#fork-the-current-conversation) e non è più un alias per questo comando |27| `/branch [name]` | Crea un ramo della conversazione corrente a questo punto. Ti sposta nel ramo e preserva l'originale, al quale puoi tornare con `/resume`. Alias: `/fork`. Quando [`CLAUDE_CODE_FORK_SUBAGENT`](/it/env-vars) è impostato, `/fork` invece avvia un [subagent con fork](/it/sub-agents#fork-the-current-conversation) e non è più un alias per questo comando |

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

28| `/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 |30| `/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 |

29| `/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` |31| `/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` |

30| `/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. Quando [Remote Control](/it/remote-control) è connesso, il colore si sincronizza con claude.ai/code |32| `/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 |

31| `/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) |33| `/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) |

32| `/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` |34| `/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` |

33| `/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à |35| `/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à |

44| `/fast [on\|off]` | Attiva o disattiva la [modalità veloce](/it/fast-mode) |46| `/fast [on\|off]` | Attiva o disattiva la [modalità veloce](/it/fast-mode) |

46| `/fewer-permission-prompts` | **[Skill](/it/skills#bundled-skills).** Scansiona i tuoi trascritti per le comuni chiamate Bash e MCP tool di sola lettura, quindi aggiungi una lista di autorizzazione prioritaria al progetto `.claude/settings.json` per ridurre i prompt di permesso |48| `/fewer-permission-prompts` | **[Skill](/it/skills#bundled-skills).** Scansiona i tuoi trascritti per le comuni chiamate Bash e MCP tool di sola lettura, quindi aggiungi una lista di autorizzazione prioritaria al progetto `.claude/settings.json` per ridurre i prompt di permesso |

47| `/focus` | Attiva/disattiva la vista focus, che mostra solo il tuo ultimo prompt, un riassunto di una riga della chiamata dello strumento con diffstat di modifica e la risposta finale. La selezione persiste tra le sessioni. Disponibile solo nel [rendering a schermo intero](/it/fullscreen) |49| `/focus` | Attiva/disattiva la vista focus, che mostra solo il tuo ultimo prompt, un riassunto di una riga della chiamata dello strumento con diffstat di modifica e la risposta finale. La selezione persiste tra le sessioni; imposta [`viewMode`](/it/settings#available-settings) nelle impostazioni per ignorarla. Disponibile solo nel [rendering a schermo intero](/it/fullscreen) |

48| `/heapdump` | Scrivi uno snapshot dell'heap JavaScript e una ripartizione della memoria su `~/Desktop`, o la tua home directory su Linux senza una cartella Desktop, per diagnosticare l'utilizzo elevato della memoria. Vedi [risoluzione dei problemi](/it/troubleshooting#high-cpu-or-memory-usage) |50| `/heapdump` | Scrivi uno snapshot dell'heap JavaScript e una ripartizione della memoria su `~/Desktop`, o la tua home directory su Linux senza una cartella Desktop, per diagnosticare l'utilizzo elevato della memoria. Vedi [risoluzione dei problemi](/it/troubleshooting#high-cpu-or-memory-usage) |

83| `/setup-bedrock` | Configura l'autenticazione [Amazon Bedrock](/it/amazon-bedrock), la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_BEDROCK=1` è impostato. Gli utenti di Bedrock per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |85| `/setup-bedrock` | Configura l'autenticazione [Amazon Bedrock](/it/amazon-bedrock), la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_BEDROCK=1` è impostato. Gli utenti di Bedrock per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |

84| `/setup-vertex` | Configura l'autenticazione [Google Vertex AI](/it/google-vertex-ai), il progetto, la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_VERTEX=1` è impostato. Gli utenti di Vertex AI per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |86| `/setup-vertex` | Configura l'autenticazione [Google Vertex AI](/it/google-vertex-ai), il progetto, la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_VERTEX=1` è impostato. Gli utenti di Vertex AI per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |

85| `/simplify [focus]` | **[Skill](/it/skills#bundled-skills).** Rivedi i tuoi file modificati di recente per il riutilizzo del codice, la qualità e i problemi di efficienza, quindi correggili. Avvia tre agenti di revisione in parallelo, aggrega i loro risultati e applica le correzioni. Passa il testo per focalizzarti su preoccupazioni specifiche: `/simplify focus on memory efficiency` |87| `/simplify [focus]` | **[Skill](/it/skills#bundled-skills).** Rivedi i tuoi file modificati di recente per il riutilizzo del codice, la qualità e i problemi di efficienza, quindi correggili. Avvia tre agenti di revisione in parallelo, aggrega i loro risultati e applica le correzioni. Passa il testo per focalizzarti su preoccupazioni specifiche: `/simplify focus on memory efficiency` |

86| `/skills` | Elenca le [skills](/it/skills) disponibili. Premi `t` per ordinare per conteggio dei token |88| `/skills` | Elenca le [skills](/it/skills) disponibili. Premi `t` per ordinare per conteggio dei token. Premi `Space` per [nascondere una skill da Claude o dal menu `/`](/it/skills#override-skill-visibility-from-settings), quindi `Enter` per salvare |

88| `/status` | Apri l'interfaccia Impostazioni (scheda Stato) che mostra versione, modello, account e connettività. Funziona mentre Claude sta rispondendo, senza aspettare il completamento della risposta corrente |90| `/status` | Apri l'interfaccia Impostazioni (scheda Stato) che mostra versione, modello, account e connettività. Funziona mentre Claude sta rispondendo, senza aspettare il completamento della risposta corrente |

89| `/statusline` | Configura la [linea di stato](/it/statusline) di Claude Code. Descrivi cosa desideri, oppure esegui senza argomenti per auto-configurare dal tuo prompt della shell |91| `/statusline` | Configura la [linea di stato](/it/statusline) di Claude Code. Descrivi cosa desideri, oppure esegui senza argomenti per auto-configurare dal tuo prompt della shell |

92| `/team-onboarding` | Genera una guida di onboarding del team dalla tua cronologia di utilizzo di Claude Code. Claude analizza le tue sessioni, comandi e utilizzo del server MCP degli ultimi 30 giorni e produce una guida markdown che un collega può incollare come primo messaggio per configurarsi rapidamente |94| `/team-onboarding` | Genera una guida di onboarding del team dalla tua cronologia di utilizzo di Claude Code. Claude analizza le tue sessioni, comandi e utilizzo del server MCP degli ultimi 30 giorni e produce una guida markdown che un collega può incollare come primo messaggio per configurarsi rapidamente. Per gli abbonati a claude.ai sui piani Pro, Max, Team ed Enterprise, restituisce anche un link di condivisione che i colleghi possono aprire direttamente in Claude Code |

93| `/teleport` | Estrai una sessione [Claude Code sul web](/it/claude-code-on-the-web#from-web-to-terminal) in questo terminale: apre un selettore, quindi recupera il ramo e la conversazione. Disponibile anche come `/tp`. Richiede un abbonamento a claude.ai |95| `/teleport` | Estrai una sessione [Claude Code sul web](/it/claude-code-on-the-web#from-web-to-terminal) in questo terminale: apre un selettore, quindi recupera il ramo e la conversazione. Disponibile anche come `/tp`. Richiede un abbonamento a claude.ai |

94| `/terminal-setup` | Configura le scorciatoie da tastiera del terminale per Shift+Enter e altri tasti di scelta rapida. Visibile solo nei terminali che lo richiedono, come VS Code, Cursor, Windsurf, Alacritty o Zed |96| `/terminal-setup` | Configura le scorciatoie da tastiera del terminale per Shift+Enter e altri tasti di scelta rapida. Visibile solo nei terminali che lo richiedono, come VS Code, Cursor, Windsurf, Alacritty o Zed |

95| `/theme` | Cambia il tema del colore. Include un'opzione `auto` che segue la modalità scura o chiara del tuo terminale, varianti chiare e scure, temi accessibili ai daltonici (daltonizzati), temi ANSI che utilizzano la tavolozza dei colori del tuo terminale e qualsiasi [tema personalizzato](/it/terminal-config#create-a-custom-theme) da `~/.claude/themes/` o plugin. Seleziona **New custom theme…** per crearne uno |97| `/theme` | Cambia il tema del colore. Include un'opzione `auto` che segue la modalità scura o chiara del tuo terminale, varianti chiare e scure, temi accessibili ai daltonici (daltonizzati), temi ANSI che utilizzano la tavolozza dei colori del tuo terminale e qualsiasi [tema personalizzato](/it/terminal-config#create-a-custom-theme) da `~/.claude/themes/` o plugin. Seleziona **New custom theme…** per crearne uno |

debug-your-config.md +25 −5

Details

17Per dettagli su una categoria specifica, segui con il comando dedicato:17Per dettagli su una categoria specifica, segui con il comando dedicato:

18 18

19| Comando | Mostra |19| Comando | Mostra |

~~20| :------------- | :----------------------------------------------------------------------------------------------- |~~20| :--------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------- |

21| `/memory` | Quali file `CLAUDE.md` e rules sono stati caricati, più voci di memoria automatica |21| `/memory` | Quali file `CLAUDE.md` e rules sono stati caricati, più voci di memoria automatica |

22| `/skills` | Skills disponibili da fonti di progetto, utente e plugin |22| `/skills` | Skills disponibili da fonti di progetto, utente e plugin |

23| `/agents` | Subagenti configurati e le loro impostazioni |23| `/agents` | Subagenti configurati e le loro impostazioni |

25| `/mcp` | Server MCP connessi e il loro stato |25| `/mcp` | Server MCP connessi e il loro stato |

26| `/permissions` | Regole di consentimento e negazione risolte attualmente in vigore |26| `/permissions` | Regole di consentimento e negazione risolte attualmente in vigore |

27| `/doctor` | Diagnostica della configurazione: chiavi non valide, errori di schema, salute dell'installazione |27| `/doctor` | Diagnostica della configurazione: chiavi non valide, errori di schema, salute dell'installazione |

28| `/debug [issue]` | Abilita la registrazione del debug per la sessione e richiede a Claude di diagnosticare utilizzando l'output del log e i percorsi delle impostazioni |

28| `/status` | Fonti di impostazioni attive, incluso se le impostazioni gestite sono in vigore |29| `/status` | Fonti di impostazioni attive, incluso se le impostazioni gestite sono in vigore |

29 30

30Se un file di memoria manca da `/memory`, controlla la sua posizione rispetto a [come i file CLAUDE.md si caricano](/it/memory#how-claude-md-files-load). I file `CLAUDE.md` della sottodirectory si caricano su richiesta quando Claude legge un file in quella directory con lo strumento Read, non all'inizio della sessione.31Se un file di memoria manca da `/memory`, controlla la sua posizione rispetto a [come i file CLAUDE.md si caricano](/it/memory#how-claude-md-files-load). I file `CLAUDE.md` della sottodirectory si caricano su richiesta quando Claude legge un file in quella directory con lo strumento Read, non all'inizio della sessione.

41 42

42Le impostazioni si uniscono tra gli ambiti gestiti, utente, progetto e locale. Le impostazioni gestite vincono sempre quando presenti. Tra il resto, l'ambito più vicino sostituisce quello più ampio nell'ordine locale, poi progetto, poi utente. Alcune impostazioni possono anche essere impostate da flag della riga di comando o [variabili di ambiente](/it/env-vars), che agiscono come un altro livello di override. Quando un'impostazione non sembra applicarsi, il valore che hai impostato è solitamente sovrascritto da un altro ambito o da una variabile di ambiente.43Le impostazioni si uniscono tra gli ambiti gestiti, utente, progetto e locale. Le impostazioni gestite vincono sempre quando presenti. Tra il resto, l'ambito più vicino sostituisce quello più ampio nell'ordine locale, poi progetto, poi utente. Alcune impostazioni possono anche essere impostate da flag della riga di comando o [variabili di ambiente](/it/env-vars), che agiscono come un altro livello di override. Quando un'impostazione non sembra applicarsi, il valore che hai impostato è solitamente sovrascritto da un altro ambito o da una variabile di ambiente.

43 44

44Esegui `/doctor` per convalidare i tuoi file di configurazione e far emergere chiavi non valide o errori di schema. Esegui `/status` per vedere quali fonti di impostazioni sono attive, incluso se le impostazioni gestite sono in vigore. Per capire quale ambito vince per una data chiave, vedi [Come gli ambiti interagiscono](/it/settings#how-scopes-interact).45Esegui `/doctor` per convalidare i tuoi file di configurazione e far emergere chiavi non valide o errori di schema. Quando `/doctor` segnala problemi, premi `f` per inviare il rapporto diagnostico a Claude e farlo procedere attraverso le correzioni con te.

47Esegui `/status` per vedere quali fonti di impostazioni sono attive, incluso se le impostazioni gestite sono in vigore. Per capire quale ambito vince per una data chiave, vedi [Come gli ambiti interagiscono](/it/settings#how-scopes-interact).

45 48

46## Controlla i server MCP49## Controlla i server MCP

47 50

63 66

64Se `/hooks` mostra l'hook ma comunque non si attiva, il passo successivo è guardare la valutazione dell'hook dal vivo. Avvia una sessione con `claude --debug hooks` e attiva la chiamata dello strumento. Il log di debug registra ogni evento, quali matcher sono stati controllati e il codice di uscita e l'output dell'hook. Vedi [Debug hooks](/it/hooks#debug-hooks) per il formato del log e [troubleshooting degli hooks](/it/hooks-guide#limitations-and-troubleshooting) per i modelli di errore comuni.67Se `/hooks` mostra l'hook ma comunque non si attiva, il passo successivo è guardare la valutazione dell'hook dal vivo. Avvia una sessione con `claude --debug hooks` e attiva la chiamata dello strumento. Il log di debug registra ogni evento, quali matcher sono stati controllati e il codice di uscita e l'output dell'hook. Vedi [Debug hooks](/it/hooks#debug-hooks) per il formato del log e [troubleshooting degli hooks](/it/hooks-guide#limitations-and-troubleshooting) per i modelli di errore comuni.

65 68

~~66## Cause comuni~~69## Prova con una configurazione pulita

71Se i controlli mirati non isolano la causa, o la tua configurazione è in uno stato sconosciuto, confronta con una sessione che non carica nulla dalla tua configurazione usuale. Punta [`CLAUDE_CONFIG_DIR`](/it/env-vars) a una directory vuota per bypassare tutto sotto `~/.claude`, e avvia da una directory che non ha una cartella `.claude`, `.mcp.json` o `CLAUDE.md` in modo che la configurazione del progetto sia anche saltata.

73```bash theme={null}

74cd /tmp && CLAUDE_CONFIG_DIR=/tmp/claude-clean claude

75```

77La sessione pulita non ha impostazioni utente o progetto, hooks, server MCP, plugin o memoria.

79* Le impostazioni gestite si applicano comunque se la tua organizzazione le distribuisce, poiché vivono in un percorso di sistema al di fuori di `~/.claude`

80* Su Linux e Windows, ti verrà chiesto di accedere di nuovo perché le credenziali sono archiviate nella directory di configurazione

81* Su macOS, le credenziali sono nel Keychain e si trasferiscono alla sessione pulita

83Se il problema scompare qui, la causa è da qualche parte nei tuoi veri file `~/.claude` o progetto `.claude`. Reintroducili uno alla volta, copiando i file nella directory temporanea o avviando dal tuo progetto, per trovare quale. Se persiste nella sessione pulita, la causa è al di fuori della tua configurazione utente e progetto. Esegui `/status` per verificare se le impostazioni gestite sono in vigore, cerca [variabili di ambiente](/it/env-vars) che influenzano Claude Code, quindi vedi [Risoluzione dei problemi](/it/troubleshooting).

85## Controlla le cause comuni

67 86

68La maggior parte delle sorprese di configurazione risale a un piccolo insieme di regole di posizione e sintassi. Controlla questi prima di assumere un bug:87La maggior parte delle sorprese di configurazione risale a un piccolo insieme di regole di posizione e sintassi. Controlla questi prima di assumere un bug:

69 88

71| :------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |90| :------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

73| Hook non si attiva mai | Il valore di `matcher` è minuscolo, ad esempio `"bash"` | La corrispondenza è sensibile alle maiuscole. I nomi degli strumenti sono capitalizzati: `Bash`, `Edit`, `Write`, `Read`. |92| Hook non si attiva mai | Il valore di `matcher` è minuscolo, ad esempio `"bash"` | La corrispondenza è sensibile alle maiuscole. I nomi degli strumenti sono capitalizzati: `Bash`, `Edit`, `Write`, `Read`. |

74| Hook non si attiva mai | Gli hooks sono in un file `.claude/hooks.json` autonomo | Non esiste un file di hooks autonomo. Definisci gli hooks sotto la chiave `"hooks"` in `settings.json`. Vedi [hook configuration](/it/hooks). |93| Hook non si attiva mai | Gli hooks sono in un file `.claude/hooks.json` autonomo | Non esiste un file di hooks autonomo. Definisci gli hooks sotto la chiave `"hooks"` in `settings.json`. Vedi [hook configuration](/it/hooks). |

80| Subagent ignora le istruzioni di `CLAUDE.md` | I subagenti non sempre ereditano la memoria del progetto | Metti le regole critiche nel corpo del file dell'agente, che diventa il prompt di sistema del subagente. Vedi [subagent configuration](/it/sub-agents). |99| Subagent ignora le istruzioni di `CLAUDE.md` | I subagenti non sempre ereditano la memoria del progetto | Metti le regole critiche nel corpo del file dell'agente, che diventa il prompt di sistema del subagente. Vedi [subagent configuration](/it/sub-agents). |

81| La logica di pulizia non viene mai eseguita alla fine della sessione | Nessun hook `SessionEnd` configurato | Aggiungi un hook `SessionEnd` in `settings.json`. Vedi l'[elenco degli eventi di hook](/it/hooks#hook-events). |100| La logica di pulizia non viene mai eseguita alla fine della sessione | Nessun hook `SessionEnd` configurato | Aggiungi un hook `SessionEnd` in `settings.json`. Vedi l'[elenco degli eventi di hook](/it/hooks#hook-events). |

82| I server MCP in `.mcp.json` non si caricano mai | Il file è sotto `.claude/` o utilizza il formato di configurazione di Claude Desktop | La configurazione MCP del progetto va alla radice del repository come `.mcp.json`, non dentro `.claude/`. Vedi [MCP configuration](/it/mcp). |101| I server MCP in `.mcp.json` non si caricano mai | Il file è sotto `.claude/` o utilizza il formato di configurazione di Claude Desktop | La configurazione MCP del progetto va alla radice del repository come `.mcp.json`, non dentro `.claude/`. Vedi [MCP configuration](/it/mcp). |

102| Server MCP aggiunti sotto `mcpServers` in `settings.json` non appaiono mai | `settings.json` non legge una chiave `mcpServers` | Definisci i server del progetto in `.mcp.json` alla radice del repository, o esegui `claude mcp add --scope user` per i server con ambito utente. Vedi [MCP configuration](/it/mcp). |

83| Server MCP del progetto aggiunto ma non appare | Il prompt di approvazione una tantum è stato chiuso | I server con ambito di progetto richiedono approvazione. Esegui `/mcp` per vedere lo stato e approvare. |103| Server MCP del progetto aggiunto ma non appare | Il prompt di approvazione una tantum è stato chiuso | I server con ambito di progetto richiedono approvazione. Esegui `/mcp` per vedere lo stato e approvare. |

84| Il server MCP non riesce ad avviarsi da alcune directory | `command` o `args` utilizza un percorso di file relativo | Usa percorsi assoluti per gli script locali. Gli eseguibili sul tuo `PATH` come `npx` o `uvx` funzionano così come sono. |104| Il server MCP non riesce ad avviarsi da alcune directory | `command` o `args` utilizza un percorso di file relativo | Usa percorsi assoluti per gli script locali. Gli eseguibili sul tuo `PATH` come `npx` o `uvx` funzionano così come sono. |

85| Il server MCP si avvia senza le variabili di ambiente previste | Le variabili sono in `settings.json` `env`, che non si propaga ai processi figlio MCP | Imposta invece `env` per server in `.mcp.json`. |105| Il server MCP si avvia senza le variabili di ambiente previste | Le variabili sono in `settings.json` `env`, che non si propaga ai processi figlio MCP | Imposta invece `env` per server in `.mcp.json`. |

93* **[Settings](/it/settings)**: ordine di precedenza e l'elenco completo delle chiavi113* **[Settings](/it/settings)**: ordine di precedenza e l'elenco completo delle chiavi

94* **[Riferimento degli hooks](/it/hooks)**: nomi degli eventi, payload e formato di output `--debug hooks`114* **[Riferimento degli hooks](/it/hooks)**: nomi degli eventi, payload e formato di output `--debug hooks`

95* **[MCP](/it/mcp)**: configurazione del server, approvazione e output `/mcp`115* **[MCP](/it/mcp)**: configurazione del server, approvazione e output `/mcp`

~~96* **[Risoluzione dei problemi di installazione e accesso](/it/troubleshoot-install)**: `command not found`, PATH e problemi di autenticazione~~116* **[Troubleshooting installation and login](/it/troubleshoot-install)**: `command not found`, PATH e problemi di autenticazione

97* **[Risoluzione dei problemi](/it/troubleshooting)**: prestazioni, blocchi e problemi di ricerca117* **[Risoluzione dei problemi](/it/troubleshooting)**: prestazioni, blocchi e problemi di ricerca

discover-plugins.md +19 −11

Details

4 4

5# Scopri e installa plugin precostruiti tramite marketplace5# Scopri e installa plugin precostruiti tramite marketplace

6 6

~~7> Trova e installa plugin dai marketplace per estendere Claude Code con nuovi comandi, agenti e funzionalità.~~7> Trova e installa plugin dai marketplace per estendere Claude Code con nuove skills, agenti e funzionalità.

8 8

9I plugin estendono Claude Code con skills, agenti, hooks e MCP servers. I marketplace dei plugin sono cataloghi che vi aiutano a scoprire e installare queste estensioni senza doverle costruire da soli.9I plugin estendono Claude Code con skills, agenti, hooks e MCP servers. I marketplace dei plugin sono cataloghi che vi aiutano a scoprire e installare queste estensioni senza doverle costruire da soli.

10 10

36/plugin install github@claude-plugins-official36/plugin install github@claude-plugins-official

37```37```

38 38

39Se Claude Code segnala che il plugin non è trovato in alcun marketplace, il vostro marketplace è mancante o obsoleto. Eseguite `/plugin marketplace update claude-plugins-official` per aggiornarlo, oppure `/plugin marketplace add anthropics/claude-plugins-official` se non lo avete ancora aggiunto. Quindi riprovate l'installazione.

39<Note>41<Note>

40 Il marketplace ufficiale è mantenuto da Anthropic. Per inviare un plugin al marketplace ufficiale, utilizzate uno dei moduli di invio in-app:42 Il marketplace ufficiale è mantenuto da Anthropic. Per inviare un plugin al marketplace ufficiale, utilizzate uno dei moduli di invio in-app:

41 43

95 97

96### Flussi di lavoro di sviluppo98### Flussi di lavoro di sviluppo

97 99

~~98Plugin che aggiungono comandi e agenti per attività di sviluppo comuni:~~100Plugin che aggiungono skills e agenti per attività di sviluppo comuni:

99 101

100* **commit-commands**: Flussi di lavoro di commit Git inclusi commit, push e creazione di PR102* **commit-commands**: Flussi di lavoro di commit Git inclusi commit, push e creazione di PR

101* **pr-review-toolkit**: Agenti specializzati per la revisione delle pull request103* **pr-review-toolkit**: Agenti specializzati per la revisione delle pull request

142 * **Project scope**: installate per tutti i collaboratori su questo repository144 * **Project scope**: installate per tutti i collaboratori su questo repository

143 * **Local scope**: installate per voi stessi solo in questo repository145 * **Local scope**: installate per voi stessi solo in questo repository

144 146

145 Ad esempio, selezionate **commit-commands** (un plugin che aggiunge comandi di flusso di lavoro git) e installatelo nel vostro ambito utente.147 Ad esempio, selezionate **commit-commands** (un plugin che aggiunge skills di flusso di lavoro git) e installatelo nel vostro ambito utente.

146 148

147 Potete anche installare direttamente dalla riga di comando:149 Potete anche installare direttamente dalla riga di comando:

148 150

154 </Step>156 </Step>

155 157

156 <Step title="Utilizzare il vostro nuovo plugin">158 <Step title="Utilizzare il vostro nuovo plugin">

157 Dopo l'installazione, eseguite `/reload-plugins` per attivare il plugin. I comandi dei plugin sono nello spazio dei nomi del nome del plugin, quindi **commit-commands** fornisce comandi come `/commit-commands:commit`.159 Dopo l'installazione, eseguite `/reload-plugins` per attivare il plugin. Le skills dei plugin sono nello spazio dei nomi del nome del plugin, quindi **commit-commands** fornisce skills come `/commit-commands:commit`.

158 160

159 Provate eseguendo una modifica a un file e eseguendo:161 Provate eseguendo una modifica a un file e eseguendo:

160 162

164 166

165 Questo mette in stage le vostre modifiche, genera un messaggio di commit e crea il commit.167 Questo mette in stage le vostre modifiche, genera un messaggio di commit e crea il commit.

166 168

167 Ogni plugin funziona diversamente. Controllate la descrizione del plugin nella scheda **Discover** o la sua homepage per sapere quali comandi e funzionalità fornisce.169 Ogni plugin funziona diversamente. Controllate la descrizione del plugin nella scheda **Discover** o la sua homepage per sapere quali skills e funzionalità fornisce.

168 </Step>170 </Step>

169</Steps>171</Steps>

170 172

195 197

196### Aggiungere da altri host Git198### Aggiungere da altri host Git

197 199

198Aggiungete qualsiasi repository git fornendo l'URL completo. Questo funziona con qualsiasi host Git, inclusi GitLab, Bitbucket e server self-hosted:200Aggiungete qualsiasi repository git fornendo l'URL completo. Questo funziona con qualsiasi host Git, inclusi GitLab, Bitbucket e server self-hosted. Includete il suffisso `.git` in modo che Claude Code cloni il repository piuttosto che trattare l'URL come un collegamento diretto a un file `marketplace.json` ospitato.

199 201

200Utilizzando HTTPS:202Utilizzando HTTPS:

201 203

257 259

258Potete anche vedere plugin con ambito **managed**—questi sono installati dagli amministratori tramite [impostazioni gestite](/it/settings#settings-files) e non possono essere modificati.260Potete anche vedere plugin con ambito **managed**—questi sono installati dagli amministratori tramite [impostazioni gestite](/it/settings#settings-files) e non possono essere modificati.

259 261

260Eseguite `/plugin` e andate alla scheda **Installed** per vedere i vostri plugin raggruppati per ambito.

~~261~~

262<Warning>262<Warning>

263 Assicuratevi di fidarvi di un plugin prima di installarlo. Anthropic non controlla quali MCP server, file o altro software sono inclusi nei plugin e non può verificare che funzionino come previsto. Controllate la homepage di ogni plugin per ulteriori informazioni.263 Assicuratevi di fidarvi di un plugin prima di installarlo. Anthropic non controlla quali MCP server, file o altro software sono inclusi nei plugin e non può verificare che funzionino come previsto. Controllate la homepage di ogni plugin per ulteriori informazioni.

264</Warning>264</Warning>

265 265

266## Gestire i plugin installati266## Gestire i plugin installati

267 267

268Eseguite `/plugin` e andate alla scheda **Installed** per visualizzare, abilitare, disabilitare o disinstallare i vostri plugin. Digitate per filtrare l'elenco per nome o descrizione del plugin.268Eseguite `/plugin` e andate alla scheda **Installed** per visualizzare, abilitare, disabilitare o disinstallare i vostri plugin. L'elenco è raggruppato per ambito e ordinato in modo che vediate prima i problemi: i plugin con errori di caricamento o dipendenze non risolte appaiono in alto, seguiti dai vostri preferiti, con i plugin disabilitati ripiegati dietro un'intestazione compressa in fondo.

269

270Dall'elenco potete:

271

272* premere `f` per contrassegnare come preferito o rimuovere il contrassegno dal plugin selezionato

273* digitare per filtrare per nome o descrizione del plugin

274* premere Enter per aprire la vista dettagli di un plugin e abilitare, disabilitare o disinstallarlo

275

276Quando installate un plugin che dichiara dipendenze, l'output dell'installazione elenca quali dipendenze sono state installate automaticamente insieme ad esso.

269 277

270Potete anche gestire i plugin con comandi diretti.278Potete anche gestire i plugin con comandi diretti.

271 279

400 408

4011. **Controllate la vostra versione**: Eseguite `claude --version` per vedere cosa è installato.4091. **Controllate la vostra versione**: Eseguite `claude --version` per vedere cosa è installato.

4022. **Aggiornate Claude Code**:4102. **Aggiornate Claude Code**:

403 * **Homebrew**: `brew upgrade claude-code`411 * **Homebrew**: `brew upgrade claude-code` (o `brew upgrade claude-code@latest` se avete installato quel cask)

404 * **npm**: `npm update -g @anthropic-ai/claude-code`412 * **npm**: `npm install -g @anthropic-ai/claude-code@latest`

405 * **Programma di installazione nativo**: Rieseguite il comando di installazione da [Setup](/it/setup)413 * **Programma di installazione nativo**: Rieseguite il comando di installazione da [Setup](/it/setup)

4063. **Riavviate Claude Code**: Dopo l'aggiornamento, riavviate il vostro terminale ed eseguite `claude` di nuovo.4143. **Riavviate Claude Code**: Dopo l'aggiornamento, riavviate il vostro terminale ed eseguite `claude` di nuovo.

407 415

env-vars.md +19 −13

Details

42| `ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION` | Sovrascrivi la regione AWS per il modello di classe Haiku quando utilizzi Bedrock o Bedrock Mantle |42| `ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION` | Sovrascrivi la regione AWS per il modello di classe Haiku quando utilizzi Bedrock o Bedrock Mantle |

43| `ANTHROPIC_VERTEX_BASE_URL` | Sovrascrivi l'URL dell'endpoint Vertex AI. Utilizza per endpoint Vertex personalizzati o quando instrada attraverso un [gateway LLM](/it/llm-gateway). Vedi [Google Vertex AI](/it/google-vertex-ai) |43| `ANTHROPIC_VERTEX_BASE_URL` | Sovrascrivi l'URL dell'endpoint Vertex AI. Utilizza per endpoint Vertex personalizzati o quando instrada attraverso un [gateway LLM](/it/llm-gateway). Vedi [Google Vertex AI](/it/google-vertex-ai) |

44| `ANTHROPIC_VERTEX_PROJECT_ID` | ID progetto GCP per Vertex AI. Obbligatorio quando si utilizza [Google Vertex AI](/it/google-vertex-ai) |44| `ANTHROPIC_VERTEX_PROJECT_ID` | ID progetto GCP per le richieste Vertex AI. Sovrascritto da `GCLOUD_PROJECT`, `GOOGLE_CLOUD_PROJECT` o dal progetto nel tuo file di credenziali `GOOGLE_APPLICATION_CREDENTIALS`. Vedi [Google Vertex AI](/it/google-vertex-ai) |

45| `API_TIMEOUT_MS` | Timeout per le richieste API in millisecondi (predefinito: 600000, o 10 minuti; massimo: 2147483647). Aumenta questo valore quando le richieste scadono su reti lente o quando instrada attraverso un proxy. I valori superiori al massimo causano un overflow del timer sottostante e causano il fallimento immediato delle richieste |45| `API_TIMEOUT_MS` | Timeout per le richieste API in millisecondi (predefinito: 600000, o 10 minuti; massimo: 2147483647). Aumenta questo valore quando le richieste scadono su reti lente o quando instrada attraverso un proxy. I valori superiori al massimo causano un overflow del timer sottostante e causano il fallimento immediato delle richieste |

46| `AWS_BEARER_TOKEN_BEDROCK` | Chiave API Bedrock per l'autenticazione (vedi [Chiavi API Bedrock](https://aws.amazon.com/blogs/machine-learning/accelerate-ai-development-with-amazon-bedrock-api-keys/)) |46| `AWS_BEARER_TOKEN_BEDROCK` | Chiave API Bedrock per l'autenticazione (vedi [Chiavi API Bedrock](https://aws.amazon.com/blogs/machine-learning/accelerate-ai-development-with-amazon-bedrock-api-keys/)) |

51| `CLAUDECODE` | Imposta su `1` negli ambienti shell che Claude Code genera (strumento Bash, sessioni tmux). Non impostato negli [hook](/it/hooks) o nei comandi della [linea di stato](/it/statusline). Utilizza per rilevare quando uno script è in esecuzione all'interno di una shell generata da Claude Code |51| `CLAUDECODE` | Imposta su `1` negli ambienti shell che Claude Code genera (strumento Bash, sessioni tmux). Non impostato negli [hook](/it/hooks) o nei comandi della [linea di stato](/it/statusline). Utilizza per rilevare quando uno script è in esecuzione all'interno di una shell generata da Claude Code |

52| `CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS` | Imposta su `1` per disabilitare tutti i tipi di [subagent](/it/sub-agents) integrati come Explore e Plan. Si applica solo in modalità non interattiva (il flag `-p`). Utile per gli utenti SDK che desiderano una lavagna pulita |52| `CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS` | Imposta su `1` per disabilitare tutti i tipi di [subagent](/it/sub-agents) integrati come Explore e Plan. Si applica solo in modalità non interattiva (il flag `-p`). Utile per gli utenti SDK che desiderano una lavagna pulita |

53| `CLAUDE_AGENT_SDK_MCP_NO_PREFIX` | Imposta su `1` per saltare il prefisso `mcp__<server>__` sui nomi degli strumenti dai server MCP creati da SDK. Gli strumenti utilizzano i loro nomi originali. Solo utilizzo SDK |53| `CLAUDE_AGENT_SDK_MCP_NO_PREFIX` | Imposta su `1` per saltare il prefisso `mcp__<server>__` sui nomi degli strumenti dai server MCP creati da SDK. Gli strumenti utilizzano i loro nomi originali. Solo utilizzo SDK |

54| `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS` | Timeout di stallo in millisecondi per i subagent in background. Predefinito `600000` (10 minuti). Il timer si ripristina su ogni evento di progresso dello streaming; se nessun progresso arriva entro la finestra, il subagent viene interrotto e l'attività viene contrassegnata come non riuscita, mostrando qualsiasi risultato parziale al genitore |

54| `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` | Imposta la percentuale della capacità del contesto (1-100) a cui viene attivata la compattazione automatica. Per impostazione predefinita, la compattazione automatica si attiva a circa il 95% della capacità. Utilizza valori inferiori come `50` per compattare prima. I valori superiori alla soglia predefinita non hanno effetto. Si applica sia alle conversazioni principali che ai subagent. Questa percentuale si allinea con il campo `context_window.used_percentage` disponibile nella [linea di stato](/it/statusline) |55| `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` | Imposta la percentuale della capacità del contesto (1-100) a cui viene attivata la compattazione automatica. Per impostazione predefinita, la compattazione automatica si attiva a circa il 95% della capacità. Utilizza valori inferiori come `50` per compattare prima. I valori superiori alla soglia predefinita non hanno effetto. Si applica sia alle conversazioni principali che ai subagent. Questa percentuale si allinea con il campo `context_window.used_percentage` disponibile nella [linea di stato](/it/statusline) |

55| `CLAUDE_AUTO_BACKGROUND_TASKS` | Imposta su `1` per forzare l'abilitazione dello sfondo automatico delle attività di agenti a lunga esecuzione. Quando abilitato, i subagent vengono spostati in background dopo l'esecuzione per circa due minuti |56| `CLAUDE_AUTO_BACKGROUND_TASKS` | Imposta su `1` per forzare l'abilitazione dello sfondo automatico delle attività di agenti a lunga esecuzione. Quando abilitato, i subagent vengono spostati in background dopo l'esecuzione per circa due minuti |

56| `CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR` | Ritorna alla directory di lavoro originale dopo ogni comando Bash o PowerShell nella sessione principale |57| `CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR` | Ritorna alla directory di lavoro originale dopo ogni comando Bash o PowerShell nella sessione principale |

59| `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` | Intervallo in millisecondi a cui le credenziali devono essere aggiornate (quando si utilizza [`apiKeyHelper`](/it/settings#available-settings)) |60| `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` | Intervallo in millisecondi a cui le credenziali devono essere aggiornate (quando si utilizza [`apiKeyHelper`](/it/settings#available-settings)) |

60| `CLAUDE_CODE_ATTRIBUTION_HEADER` | Imposta su `0` per omettere il blocco di attribuzione (versione client e impronta digitale del prompt) dall'inizio del prompt di sistema. Disabilitarlo migliora i tassi di hit della cache dei prompt quando si instrada attraverso un [gateway LLM](/it/llm-gateway). Il caching dell'API Anthropic non è interessato |61| `CLAUDE_CODE_ATTRIBUTION_HEADER` | Imposta su `0` per omettere il blocco di attribuzione (versione client e impronta digitale del prompt) dall'inizio del prompt di sistema. Disabilitarlo migliora i tassi di hit della cache dei prompt quando si instrada attraverso un [gateway LLM](/it/llm-gateway). Il caching dell'API Anthropic non è interessato |

61| `CLAUDE_CODE_AUTO_COMPACT_WINDOW` | Imposta la capacità del contesto in token utilizzata per i calcoli di compattazione automatica. Per impostazione predefinita, la finestra del contesto del modello: 200K per i modelli standard o 1M per i modelli con [contesto esteso](/it/model-config#extended-context). Utilizza un valore inferiore come `500000` su un modello 1M per trattare la finestra come 500K ai fini della compattazione. Il valore è limitato alla finestra del contesto effettiva del modello. `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` viene applicato come percentuale di questo valore. L'impostazione di questa variabile disaccoppia la soglia di compattazione dalla `used_percentage` della linea di stato, che utilizza sempre la finestra del contesto completa del modello |62| `CLAUDE_CODE_AUTO_COMPACT_WINDOW` | Imposta la capacità del contesto in token utilizzata per i calcoli di compattazione automatica. Per impostazione predefinita, la finestra del contesto del modello: 200K per i modelli standard o 1M per i modelli con [contesto esteso](/it/model-config#extended-context). Utilizza un valore inferiore come `500000` su un modello 1M per trattare la finestra come 500K ai fini della compattazione. Il valore è limitato alla finestra del contesto effettiva del modello. `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` viene applicato come percentuale di questo valore. L'impostazione di questa variabile disaccoppia la soglia di compattazione dalla `used_percentage` della linea di stato, che utilizza sempre la finestra del contesto completa del modello |

62| `CLAUDE_CODE_AUTO_CONNECT_IDE` | Sovrascrivi la [connessione IDE](/it/vs-code) automatica. Per impostazione predefinita, Claude Code si connette automaticamente quando avviato all'interno del terminale integrato di un IDE supportato. Imposta su `false` per impedire questo. Imposta su `true` per forzare un tentativo di connessione quando l'auto-rilevamento fallisce, ad esempio quando tmux oscura il terminale padre |63| `CLAUDE_CODE_AUTO_CONNECT_IDE` | Sovrascrivi la [connessione IDE](/it/vs-code) automatica. Per impostazione predefinita, Claude Code si connette automaticamente quando avviato all'interno del terminale integrato di un IDE supportato. Imposta su `false` per impedire questo. Imposta su `true` per forzare un tentativo di connessione quando l'auto-rilevamento fallisce, ad esempio quando tmux oscura il terminale padre. Ha la precedenza sull'impostazione globale [`autoConnectIde`](/it/settings#global-config-settings) |

63| `CLAUDE_CODE_CERT_STORE` | Elenco separato da virgole di fonti di certificati CA per le connessioni TLS. `bundled` è il set Mozilla CA fornito con Claude Code. `system` è l'archivio di fiducia del sistema operativo. Per impostazione predefinita è `bundled,system`. La distribuzione binaria nativa è richiesta per l'integrazione dell'archivio di sistema. Nel runtime Node.js, viene utilizzato solo il set raggruppato indipendentemente da questo valore |64| `CLAUDE_CODE_CERT_STORE` | Elenco separato da virgole di fonti di certificati CA per le connessioni TLS. `bundled` è il set Mozilla CA fornito con Claude Code. `system` è l'archivio di fiducia del sistema operativo. Per impostazione predefinita è `bundled,system` |

68| `CLAUDE_CODE_DEBUG_LOG_LEVEL` | Livello di log minimo scritto nel file di log di debug. Valori: `verbose`, `debug` (predefinito), `info`, `warn`, `error`. Imposta su `verbose` per includere diagnostica ad alto volume come l'output completo del comando della linea di stato, o aumenta a `error` per ridurre il rumore |69| `CLAUDE_CODE_DEBUG_LOG_LEVEL` | Livello di log minimo scritto nel file di log di debug. Valori: `verbose`, `debug` (predefinito), `info`, `warn`, `error`. Imposta su `verbose` per includere diagnostica ad alto volume come l'output completo del comando della linea di stato, o aumenta a `error` per ridurre il rumore |

69| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | Imposta su `1` per disabilitare il supporto della [finestra del contesto 1M](/it/model-config#extended-context). Se impostato, le varianti del modello 1M non sono disponibili nel selettore di modelli. Utile per ambienti aziendali con requisiti di conformità |70| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | Imposta su `1` per disabilitare il supporto della [finestra del contesto 1M](/it/model-config#extended-context). Se impostato, le varianti del modello 1M non sono disponibili nel selettore di modelli. Utile per ambienti aziendali con requisiti di conformità |

70| `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` | Imposta su `1` per disabilitare il [ragionamento adattivo](/it/model-config#adjust-effort-level) su Opus 4.6 e Sonnet 4.6 e tornare al budget di thinking fisso controllato da `MAX_THINKING_TOKENS`. {/* min-version: 2.1.111 */}Non ha effetto su Opus 4.7, che utilizza sempre il ragionamento adattivo |71| `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` | Imposta su `1` per disabilitare il [ragionamento adattivo](/it/model-config#adjust-effort-level) su Opus 4.6 e Sonnet 4.6 e tornare al budget di thinking fisso controllato da `MAX_THINKING_TOKENS`. {/* min-version: 2.1.111 */}Non ha effetto su Opus 4.7, che utilizza sempre il ragionamento adattivo |

72| `CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN` | Imposta su `1` per disabilitare il [rendering a schermo intero](/it/fullscreen) e utilizzare il renderer della schermata principale classica. La conversazione rimane nello scrollback nativo del tuo terminale in modo che `Cmd+f` e la modalità di copia di tmux funzionino come al solito. Ha la precedenza su `CLAUDE_CODE_NO_FLICKER` e sull'impostazione [`tui`](/it/settings#available-settings). Puoi anche passare con `/tui default` |

71| `CLAUDE_CODE_DISABLE_ATTACHMENTS` | Imposta su `1` per disabilitare l'elaborazione degli allegati. Le menzioni di file con la sintassi `@` vengono inviate come testo semplice invece di essere espanse nel contenuto del file |73| `CLAUDE_CODE_DISABLE_ATTACHMENTS` | Imposta su `1` per disabilitare l'elaborazione degli allegati. Le menzioni di file con la sintassi `@` vengono inviate come testo semplice invece di essere espanse nel contenuto del file |

72| `CLAUDE_CODE_DISABLE_AUTO_MEMORY` | Imposta su `1` per disabilitare la [memoria automatica](/it/memory#auto-memory). Imposta su `0` per forzare la memoria automatica durante il rollout graduale. Se disabilitato, Claude non crea o carica i file di memoria automatica |74| `CLAUDE_CODE_DISABLE_AUTO_MEMORY` | Imposta su `1` per disabilitare la [memoria automatica](/it/memory#auto-memory). Imposta su `0` per forzare la memoria automatica durante il rollout graduale quando [`autoMemoryEnabled: false`](/it/settings#available-settings) altrimenti la disabiliterebbe. Quando disabilitato, Claude non crea o carica i file di memoria automatica |

73| `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS` | Imposta su `1` per disabilitare tutta la funzionalità di attività in background, incluso il parametro `run_in_background` su strumenti Bash e subagent, auto-backgrounding e la scorciatoia Ctrl+B |75| `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS` | Imposta su `1` per disabilitare tutta la funzionalità di attività in background, incluso il parametro `run_in_background` su strumenti Bash e subagent, auto-backgrounding e la scorciatoia Ctrl+B |

74| `CLAUDE_CODE_DISABLE_CLAUDE_MDS` | Imposta su `1` per impedire il caricamento di qualsiasi file di memoria CLAUDE.md nel contesto, inclusi i file di utente, progetto e memoria automatica |76| `CLAUDE_CODE_DISABLE_CLAUDE_MDS` | Imposta su `1` per impedire il caricamento di qualsiasi file di memoria CLAUDE.md nel contesto, inclusi i file di utente, progetto e memoria automatica |

75| `CLAUDE_CODE_DISABLE_CRON` | Imposta su `1` per disabilitare le [attività pianificate](/it/scheduled-tasks). La skill `/loop` e gli strumenti cron diventano non disponibili e tutte le attività già pianificate smettono di attivarsi, incluse le attività già in esecuzione a metà sessione |77| `CLAUDE_CODE_DISABLE_CRON` | Imposta su `1` per disabilitare le [attività pianificate](/it/scheduled-tasks). La skill `/loop` e gli strumenti cron diventano non disponibili e tutte le attività già pianificate smettono di attivarsi, incluse le attività già in esecuzione a metà sessione |

76| `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS` | Imposta su `1` per rimuovere le intestazioni di richiesta `anthropic-beta` specifiche di Anthropic e i campi dello schema degli strumenti beta (come `defer_loading` e `eager_input_streaming`) dalle richieste API. Utilizza questo quando un gateway proxy rifiuta le richieste con errori come "Unexpected value(s) for the `anthropic-beta` header" o "Extra inputs are not permitted". I campi standard (`name`, `description`, `input_schema`, `cache_control`) vengono preservati. |78| `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS` | Imposta su `1` per rimuovere le intestazioni di richiesta `anthropic-beta` specifiche di Anthropic e i campi dello schema degli strumenti beta (come `defer_loading` e `eager_input_streaming`) dalle richieste API. Utilizza questo quando un gateway proxy rifiuta le richieste con errori come "Unexpected value(s) for the `anthropic-beta` header" o "Extra inputs are not permitted". I campi standard (`name`, `description`, `input_schema`, `cache_control`) vengono preservati. |

78| `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY` | Imposta su `1` per disabilitare i sondaggi sulla qualità della sessione "Come sta andando Claude?". I sondaggi sono anche disabilitati quando `DISABLE_TELEMETRY` o `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` è impostato. Vedi [Sondaggi sulla qualità della sessione](/it/data-usage#session-quality-surveys) |80| `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY` | Imposta su `1` per disabilitare i sondaggi sulla qualità della sessione "Come sta andando Claude?". I sondaggi sono anche disabilitati quando `DISABLE_TELEMETRY` o `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` è impostato. Per impostare una frequenza di campionamento invece di disabilitare completamente, utilizza l'impostazione [`feedbackSurveyRate`](/it/settings#available-settings). Vedi [Sondaggi sulla qualità della sessione](/it/data-usage#session-quality-surveys) |

79| `CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING` | Imposta su `1` per disabilitare il [checkpointing](/it/checkpointing) dei file. Il comando `/rewind` non sarà in grado di ripristinare le modifiche al codice |81| `CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING` | Imposta su `1` per disabilitare il [checkpointing](/it/checkpointing) dei file. Il comando `/rewind` non sarà in grado di ripristinare le modifiche al codice |

80| `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` | Imposta su `1` per rimuovere le istruzioni di workflow commit e PR integrate dal prompt di sistema di Claude. Utile quando si utilizzano le proprie skill di workflow git. Ha la precedenza sull'impostazione [`includeGitInstructions`](/it/settings#available-settings) se impostato |82| `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` | Imposta su `1` per rimuovere le istruzioni di workflow commit e PR integrate e lo snapshot dello stato git dal prompt di sistema di Claude. Utile quando si utilizzano le proprie skill di workflow git. Ha la precedenza sull'impostazione [`includeGitInstructions`](/it/settings#available-settings) se impostato |

81| `CLAUDE_CODE_DISABLE_LEGACY_MODEL_REMAP` | Imposta su `1` per impedire il remapping automatico di Opus 4.0 e 4.1 alla versione Opus corrente sull'API Anthropic. Utilizza quando desideri intenzionalmente fissare un modello più vecchio. Il remapping non viene eseguito su Bedrock, Vertex o Foundry |83| `CLAUDE_CODE_DISABLE_LEGACY_MODEL_REMAP` | Imposta su `1` per impedire il remapping automatico di Opus 4.0 e 4.1 alla versione Opus corrente sull'API Anthropic. Utilizza quando desideri intenzionalmente fissare un modello più vecchio. Il remapping non viene eseguito su Bedrock, Vertex o Foundry |

82| `CLAUDE_CODE_DISABLE_MOUSE` | Imposta su `1` per disabilitare il tracciamento del mouse nel [rendering a schermo intero](/it/fullscreen). Lo scorrimento da tastiera con `PgUp` e `PgDn` funziona ancora. Utilizza questo per mantenere il comportamento nativo di copia al passaggio del mouse del tuo terminale |84| `CLAUDE_CODE_DISABLE_MOUSE` | Imposta su `1` per disabilitare il tracciamento del mouse nel [rendering a schermo intero](/it/fullscreen). Lo scorrimento da tastiera con `PgUp` e `PgDn` funziona ancora. Utilizza questo per mantenere il comportamento nativo di copia al passaggio del mouse del tuo terminale |

83| `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` | Equivalente all'impostazione di `DISABLE_AUTOUPDATER`, `DISABLE_FEEDBACK_COMMAND`, `DISABLE_ERROR_REPORTING` e `DISABLE_TELEMETRY` |85| `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` | Equivalente all'impostazione di `DISABLE_AUTOUPDATER`, `DISABLE_FEEDBACK_COMMAND`, `DISABLE_ERROR_REPORTING` e `DISABLE_TELEMETRY` |

90| `CLAUDE_CODE_EFFORT_LEVEL` | Imposta il livello di sforzo per i modelli supportati. Valori: `low`, `medium`, `high`, `xhigh`, `max` o `auto` per usare il valore predefinito del modello. I livelli disponibili dipendono dal modello. Ha la precedenza su `/effort` e sull'impostazione `effortLevel`. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) |92| `CLAUDE_CODE_EFFORT_LEVEL` | Imposta il livello di sforzo per i modelli supportati. Valori: `low`, `medium`, `high`, `xhigh`, `max` o `auto` per usare il valore predefinito del modello. I livelli disponibili dipendono dal modello. Ha la precedenza su `/effort` e sull'impostazione `effortLevel`. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) |

91| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Sovrascrivi la disponibilità del [riepilogo della sessione](/it/interactive-mode#session-recap). Imposta su `0` per forzare i riepiloghi disattivati indipendentemente dall'interruttore `/config`. Imposta su `1` per forzare i riepiloghi attivati quando [`awaySummaryEnabled`](/it/settings#available-settings) è `false`. Ha la precedenza sull'impostazione e sull'interruttore `/config` |93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Sovrascrivi la disponibilità del [riepilogo della sessione](/it/interactive-mode#session-recap). Imposta su `0` per forzare i riepiloghi disattivati indipendentemente dall'interruttore `/config`. Imposta su `1` per forzare i riepiloghi attivati quando [`awaySummaryEnabled`](/it/settings#available-settings) è `false`. Ha la precedenza sull'impostazione e sull'interruttore `/config` |

92| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Imposta su `1` per aggiornare lo stato del plugin ai confini dei turni in [modalità non interattiva](/it/headless) dopo il completamento di un'installazione in background. Disattivato per impostazione predefinita perché l'aggiornamento cambia il prompt di sistema a metà sessione, il che invalida il [caching dei prompt](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) per quel turno |94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Imposta su `1` per aggiornare lo stato del plugin ai confini dei turni in [modalità non interattiva](/it/headless) dopo il completamento di un'installazione in background. Disattivato per impostazione predefinita perché l'aggiornamento cambia il prompt di sistema a metà sessione, il che invalida il [caching dei prompt](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) per quel turno |

93| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Imposta su `1` per forzare l'abilitazione dello streaming fine degli input degli strumenti. Senza questo, l'API memorizza completamente i parametri di input dello strumento prima di inviare gli eventi delta, il che può ritardare la visualizzazione su input di strumenti grandi. Solo API Anthropic: non ha effetto su Bedrock, Vertex o Foundry |95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Controlla se gli input delle chiamate di strumento vengono trasmessi dall'API mentre Claude li genera. Con questo disattivato, un input di strumento grande come una lunga scrittura di file arriva solo dopo che Claude finisce di generarlo, il che può sembrare che sia bloccato. Abilitato per impostazione predefinita per le connessioni API Anthropic dirette. Imposta su `0` per rinunciare. Imposta su `1` per forzare l'abilitazione anche quando il valore predefinito lato server è disattivato. Non ha effetto su Bedrock, Vertex, Foundry o connessioni [gateway](/it/llm-gateway) |

96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Imposta su `1` per popolare il selettore `/model` dall'endpoint `/v1/models` del tuo gateway quando `ANTHROPIC_BASE_URL` punta a un gateway compatibile con Anthropic come LiteLLM, Kong o un proxy interno. Disattivato per impostazione predefinita perché i gateway supportati da una chiave API condivisa mostrerebbero altrimenti a ogni utente ogni modello a cui la chiave può accedere. I modelli scoperti vengono comunque filtrati dall'allowlist [`availableModels`](/it/settings#available-settings) |

94| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Imposta su `false` per disabilitare i suggerimenti di prompt (l'interruttore "Prompt suggestions" in `/config`). Questi sono i suggerimenti predetti in grigio che appaiono nel tuo input di prompt dopo che Claude risponde. Vedi [Suggerimenti di prompt](/it/interactive-mode#prompt-suggestions) |97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Imposta su `false` per disabilitare i suggerimenti di prompt (l'interruttore "Prompt suggestions" in `/config`). Questi sono i suggerimenti predetti in grigio che appaiono nel tuo input di prompt dopo che Claude risponde. Vedi [Suggerimenti di prompt](/it/interactive-mode#prompt-suggestions) |

95| `CLAUDE_CODE_ENABLE_TASKS` | Imposta su `1` per abilitare il sistema di tracciamento delle attività in modalità non interattiva (il flag `-p`). Le attività sono abilitate per impostazione predefinita in modalità interattiva. Vedi [Elenco attività](/it/interactive-mode#task-list) |98| `CLAUDE_CODE_ENABLE_TASKS` | Imposta su `1` per abilitare il sistema di tracciamento delle attività in modalità non interattiva (il flag `-p`). Le attività sono abilitate per impostazione predefinita in modalità interattiva. Vedi [Elenco attività](/it/interactive-mode#task-list) |

96| `CLAUDE_CODE_ENABLE_TELEMETRY` | Imposta su `1` per abilitare la raccolta di dati OpenTelemetry per metriche e logging. Obbligatorio prima di configurare gli esportatori OTel. Vedi [Monitoraggio](/it/monitoring-usage) |99| `CLAUDE_CODE_ENABLE_TELEMETRY` | Imposta su `1` per abilitare la raccolta di dati OpenTelemetry per metriche e logging. Obbligatorio prima di configurare gli esportatori OTel. Vedi [Monitoraggio](/it/monitoring-usage) |

98| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | Imposta su `1` per abilitare i [team di agenti](/it/agent-teams). I team di agenti sono sperimentali e disabilitati per impostazione predefinita |101| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | Imposta su `1` per abilitare i [team di agenti](/it/agent-teams). I team di agenti sono sperimentali e disabilitati per impostazione predefinita |

99| `CLAUDE_CODE_EXTRA_BODY` | Oggetto JSON da unire al livello superiore di ogni corpo di richiesta API. Utile per passare parametri specifici del provider che Claude Code non espone direttamente |102| `CLAUDE_CODE_EXTRA_BODY` | Oggetto JSON da unire al livello superiore di ogni corpo di richiesta API. Utile per passare parametri specifici del provider che Claude Code non espone direttamente |

100| `CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS` | Sovrascrivi il limite di token predefinito per le letture di file. Utile quando è necessario leggere file più grandi per intero |103| `CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS` | Sovrascrivi il limite di token predefinito per le letture di file. Utile quando è necessario leggere file più grandi per intero |

101| `CLAUDE_CODE_FORK_SUBAGENT` | Imposta su `1` per abilitare i [subagent biforcati](/it/sub-agents#fork-the-current-conversation). Un subagent biforcato eredita il contesto della conversazione completa dalla sessione principale invece di iniziare da zero. Se abilitato, `/fork` genera un subagent biforcato piuttosto che agire come alias per [`/branch`](/it/commands), e tutti gli spawn di subagent vengono eseguiti in background. Funziona in modalità interattiva e tramite SDK o `claude -p` |104| `CLAUDE_CODE_FORCE_SYNC_OUTPUT` | Imposta su `1` per forzare l'abilitazione della modalità privata DEC 2026 [synchronized output](https://gist.github.com/christianparpart/d8a62cc1ab659194337d73e399004036) quando il tuo terminale la supporta ma non viene rilevato automaticamente. Utile per emulatori come Emacs `eat` che implementano BSU/ESU ma non rispondono al probe di capacità. Non ha effetto sotto tmux |

105| `CLAUDE_CODE_FORK_SUBAGENT` | Imposta su `1` per abilitare i [subagent biforcati](/it/sub-agents#fork-the-current-conversation). Un subagent biforcato eredita il contesto della conversazione completa dalla sessione principale invece di iniziare da zero. Quando abilitato, `/fork` genera un subagent biforcato piuttosto che agire come alias per [`/branch`](/it/commands), e tutti gli spawn di subagent vengono eseguiti in background. Funziona in modalità interattiva e tramite SDK o `claude -p` |

102| `CLAUDE_CODE_GIT_BASH_PATH` | Solo Windows: percorso dell'eseguibile Git Bash (`bash.exe`). Utilizza quando Git Bash è installato ma non nel tuo PATH. Vedi [Configurazione di Windows](/it/setup#set-up-on-windows) |106| `CLAUDE_CODE_GIT_BASH_PATH` | Solo Windows: percorso dell'eseguibile Git Bash (`bash.exe`). Utilizza quando Git Bash è installato ma non nel tuo PATH. Vedi [Configurazione di Windows](/it/setup#set-up-on-windows) |

103| `CLAUDE_CODE_GLOB_HIDDEN` | Imposta su `false` per escludere i dotfile dai risultati quando Claude richiama lo [strumento Glob](/it/tools-reference). Incluso per impostazione predefinita. Non influisce su `@` file autocomplete, `ls`, Grep o Read |107| `CLAUDE_CODE_GLOB_HIDDEN` | Imposta su `false` per escludere i dotfile dai risultati quando Claude richiama lo [strumento Glob](/it/tools-reference). Incluso per impostazione predefinita. Non influisce su `@` file autocomplete, `ls`, Grep o Read |

104| `CLAUDE_CODE_GLOB_NO_IGNORE` | Imposta su `false` per fare in modo che lo [strumento Glob](/it/tools-reference) rispetti i modelli `.gitignore`. Per impostazione predefinita, Glob restituisce tutti i file corrispondenti inclusi quelli gitignored. Non influisce su `@` file autocomplete, che ha la sua propria impostazione [`respectGitignore`](/it/settings#available-settings) |108| `CLAUDE_CODE_GLOB_NO_IGNORE` | Imposta su `false` per fare in modo che lo [strumento Glob](/it/tools-reference) rispetti i modelli `.gitignore`. Per impostazione predefinita, Glob restituisce tutti i file corrispondenti inclusi quelli gitignored. Non influisce su `@` file autocomplete, che ha la sua propria impostazione [`respectGitignore`](/it/settings#available-settings) |

120| `CLAUDE_CODE_OTEL_FLUSH_TIMEOUT_MS` | Timeout in millisecondi per lo scaricamento dei span OpenTelemetry in sospeso (predefinito: 5000). Vedi [Monitoraggio](/it/monitoring-usage) |124| `CLAUDE_CODE_OTEL_FLUSH_TIMEOUT_MS` | Timeout in millisecondi per lo scaricamento dei span OpenTelemetry in sospeso (predefinito: 5000). Vedi [Monitoraggio](/it/monitoring-usage) |

121| `CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS` | Intervallo per l'aggiornamento delle intestazioni OpenTelemetry dinamiche in millisecondi (predefinito: 1740000 / 29 minuti). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) |125| `CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS` | Intervallo per l'aggiornamento delle intestazioni OpenTelemetry dinamiche in millisecondi (predefinito: 1740000 / 29 minuti). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) |

122| `CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS` | Timeout in millisecondi per l'esportatore OpenTelemetry per terminare all'arresto (predefinito: 2000). Aumenta se le metriche vengono eliminate all'uscita. Vedi [Monitoraggio](/it/monitoring-usage) |126| `CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS` | Timeout in millisecondi per l'esportatore OpenTelemetry per terminare all'arresto (predefinito: 2000). Aumenta se le metriche vengono eliminate all'uscita. Vedi [Monitoraggio](/it/monitoring-usage) |

127| `CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE` | Imposta su `1` per consentire a Claude Code di eseguire il comando di aggiornamento del tuo gestore di pacchetti in background quando una nuova versione è disponibile. Si applica alle installazioni Homebrew e WinGet. Gli altri gestori di pacchetti continuano a mostrare il comando di aggiornamento senza eseguirlo. Vedi [Aggiornamenti automatici](/it/setup#auto-updates) |

123| `CLAUDE_CODE_PERFORCE_MODE` | Imposta su `1` per abilitare la protezione da scrittura consapevole di Perforce. Se impostato, Edit, Write e NotebookEdit falliscono con un suggerimento `p4 edit <file>` se il file di destinazione manca del bit di scrittura del proprietario, che Perforce cancella sui file sincronizzati fino a quando `p4 edit` non li apre. Questo impedisce a Claude Code di aggirare il tracciamento dei cambiamenti di Perforce |128| `CLAUDE_CODE_PERFORCE_MODE` | Imposta su `1` per abilitare la protezione da scrittura consapevole di Perforce. Se impostato, Edit, Write e NotebookEdit falliscono con un suggerimento `p4 edit <file>` se il file di destinazione manca del bit di scrittura del proprietario, che Perforce cancella sui file sincronizzati fino a quando `p4 edit` non li apre. Questo impedisce a Claude Code di aggirare il tracciamento dei cambiamenti di Perforce |

124| `CLAUDE_CODE_PLUGIN_CACHE_DIR` | Sovrascrivi la directory radice dei plugin. Nonostante il nome, questo imposta la directory padre, non la cache stessa: i marketplace e la cache dei plugin si trovano in sottodirectory sotto questo percorso. Per impostazione predefinita `~/.claude/plugins` |129| `CLAUDE_CODE_PLUGIN_CACHE_DIR` | Sovrascrivi la directory radice dei plugin. Nonostante il nome, questo imposta la directory padre, non la cache stessa: i marketplace e la cache dei plugin si trovano in sottodirectory sotto questo percorso. Per impostazione predefinita `~/.claude/plugins` |

125| `CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS` | Timeout in millisecondi per le operazioni git durante l'installazione o l'aggiornamento dei plugin (predefinito: 120000). Aumenta questo valore per repository di grandi dimensioni o connessioni di rete lente. Vedi [Le operazioni Git scadono](/it/plugin-marketplaces#git-operations-time-out) |130| `CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS` | Timeout in millisecondi per le operazioni git durante l'installazione o l'aggiornamento dei plugin (predefinito: 120000). Aumenta questo valore per repository di grandi dimensioni o connessioni di rete lente. Vedi [Le operazioni Git scadono](/it/plugin-marketplaces#git-operations-time-out) |

131| `CLAUDE_CODE_REMOTE_SESSION_ID` | Impostato automaticamente nelle [sessioni cloud](/it/claude-code-on-the-web) all'ID della sessione corrente. Leggi questo per costruire un collegamento alla trascrizione della sessione. Vedi [Collegare gli artefatti alla sessione](/it/claude-code-on-the-web#link-artifacts-back-to-the-session) |136| `CLAUDE_CODE_REMOTE_SESSION_ID` | Impostato automaticamente nelle [sessioni cloud](/it/claude-code-on-the-web) all'ID della sessione corrente. Leggi questo per costruire un collegamento alla trascrizione della sessione. Vedi [Collegare gli artefatti alla sessione](/it/claude-code-on-the-web#link-artifacts-back-to-the-session) |

132| `CLAUDE_CODE_RESUME_INTERRUPTED_TURN` | Imposta su `1` per riprendere automaticamente se la sessione precedente è terminata a metà turno. Utilizzato in modalità SDK in modo che il modello continui senza richiedere all'SDK di reinviare il prompt |137| `CLAUDE_CODE_RESUME_INTERRUPTED_TURN` | Imposta su `1` per riprendere automaticamente se la sessione precedente è terminata a metà turno. Utilizzato in modalità SDK in modo che il modello continui senza richiedere all'SDK di reinviare il prompt |

133| `CLAUDE_CODE_SCRIPT_CAPS` | Oggetto JSON che limita quante volte script specifici possono essere richiamati per sessione quando `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` è impostato. Le chiavi sono sottostringhe abbinate al testo del comando; i valori sono limiti di chiamate intere. Ad esempio, `{"deploy.sh": 2}` consente a `deploy.sh` di essere chiamato al massimo due volte. L'abbinamento è basato su sottostringhe quindi trucchi di espansione della shell come `./scripts/deploy.sh $(evil)` contano comunque rispetto al limite. Il fan-out di runtime tramite `xargs` o `find -exec` non viene rilevato; questo è un controllo di difesa in profondità |138| `CLAUDE_CODE_SCRIPT_CAPS` | Oggetto JSON che limita quante volte script specifici possono essere richiamati per sessione quando `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` è impostato. Le chiavi sono sottostringhe abbinate al testo del comando; i valori sono limiti di chiamate intere. Ad esempio, `{"deploy.sh": 2}` consente a `deploy.sh` di essere chiamato al massimo due volte. L'abbinamento è basato su sottostringhe quindi trucchi di espansione della shell come `./scripts/deploy.sh $(evil)` contano comunque rispetto al limite. Il fan-out di runtime tramite `xargs` o `find -exec` non viene rilevato; questo è un controllo di difesa in profondità |

134| `CLAUDE_CODE_SCROLL_SPEED` | Imposta il moltiplicatore di scorrimento della rotella del mouse nel [rendering a schermo intero](/it/fullscreen#mouse-wheel-scrolling). Accetta valori da 1 a 20. Imposta su `3` per corrispondere a `vim` se il tuo terminale invia un evento di rotella per tacca senza amplificazione |139| `CLAUDE_CODE_SCROLL_SPEED` | Imposta il moltiplicatore di scorrimento della rotella del mouse nel [rendering a schermo intero](/it/fullscreen#mouse-wheel-scrolling). Accetta valori da 1 a 20. Imposta su `3` per corrispondere a `vim` se il tuo terminale invia un evento di rotella per tacca senza amplificazione. Ignorato nel terminale IDE JetBrains, dove Claude Code utilizza il proprio gestore di scorrimento |

135| `CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS` | Sovrascrivi il budget di tempo in millisecondi per gli hook [SessionEnd](/it/hooks#sessionend). Si applica all'uscita della sessione, `/clear` e al cambio di sessioni tramite `/resume` interattivo. Per impostazione predefinita il budget è 1,5 secondi, aumentato automaticamente al massimo `timeout` per hook configurato nei file di impostazioni, fino a 60 secondi. I timeout sugli hook forniti dai plugin non aumentano il budget |140| `CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS` | Sovrascrivi il budget di tempo in millisecondi per gli hook [SessionEnd](/it/hooks#sessionend). Si applica all'uscita della sessione, `/clear` e al cambio di sessioni tramite `/resume` interattivo. Per impostazione predefinita il budget è 1,5 secondi, aumentato automaticamente al massimo `timeout` per hook configurato nei file di impostazioni, fino a 60 secondi. I timeout sugli hook forniti dai plugin non aumentano il budget |

141| `CLAUDE_CODE_SESSION_ID` | Impostato automaticamente nei sottoprocessi dello strumento Bash e PowerShell all'ID della sessione corrente. Corrisponde al campo `session_id` passato agli [hook](/it/hooks). Aggiornato su `/clear`. Utilizza per correlare script e strumenti esterni con la sessione Claude Code che li ha avviati |

136| `CLAUDE_CODE_SHELL` | Sovrascrivi il rilevamento automatico della shell. Utile quando la tua shell di login differisce dalla tua shell di lavoro preferita (ad esempio, `bash` vs `zsh`) |142| `CLAUDE_CODE_SHELL` | Sovrascrivi il rilevamento automatico della shell. Utile quando la tua shell di login differisce dalla tua shell di lavoro preferita (ad esempio, `bash` vs `zsh`) |

137| `CLAUDE_CODE_SHELL_PREFIX` | Prefisso del comando che avvolge i comandi shell che Claude Code genera: chiamate dello strumento Bash, comandi [hook](/it/hooks) e comandi di avvio del server MCP stdio. Utile per logging o auditing. Esempio: impostando `/path/to/logger.sh` esegue ogni comando come `/path/to/logger.sh <command>` |143| `CLAUDE_CODE_SHELL_PREFIX` | Prefisso del comando che avvolge i comandi shell che Claude Code genera: chiamate dello strumento Bash, comandi [hook](/it/hooks) e comandi di avvio del server MCP stdio. Utile per logging o auditing. Esempio: impostando `/path/to/logger.sh` esegue ogni comando come `/path/to/logger.sh <command>` |

138| `CLAUDE_CODE_SIMPLE` | Imposta su `1` per eseguire con un prompt di sistema minimo e solo gli strumenti Bash, lettura file e modifica file. Gli strumenti MCP da `--mcp-config` sono ancora disponibili. Disabilita l'auto-discovery di hook, skill, plugin, server MCP, memoria automatica e CLAUDE.md. Il flag CLI [`--bare`](/it/headless#start-faster-with-bare-mode) imposta questo |144| `CLAUDE_CODE_SIMPLE` | Imposta su `1` per eseguire con un prompt di sistema minimo e solo gli strumenti Bash, lettura file e modifica file. Gli strumenti MCP da `--mcp-config` sono ancora disponibili. Disabilita l'auto-discovery di hook, skill, plugin, server MCP, memoria automatica e CLAUDE.md. Il flag CLI [`--bare`](/it/headless#start-faster-with-bare-mode) imposta questo |

146| `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` | Imposta su `1` per rimuovere le credenziali Anthropic e del provider cloud dagli ambienti dei sottoprocessi (strumento Bash, hook, server MCP stdio). Il processo Claude padre mantiene queste credenziali per le chiamate API, ma i processi figlio non possono leggerle, riducendo l'esposizione agli attacchi di prompt injection che tentano di esfiltare i segreti tramite l'espansione della shell. Su Linux, questo esegue anche i sottoprocessi Bash in uno spazio dei nomi PID isolato in modo che non possano leggere gli ambienti dei processi host tramite `/proc`; come effetto collaterale, `ps`, `pgrep` e `kill` non possono vedere o segnalare i processi host. `claude-code-action` imposta questo automaticamente quando `allowed_non_write_users` è configurato |152| `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` | Imposta su `1` per rimuovere le credenziali Anthropic e del provider cloud dagli ambienti dei sottoprocessi (strumento Bash, hook, server MCP stdio). Il processo Claude padre mantiene queste credenziali per le chiamate API, ma i processi figlio non possono leggerle, riducendo l'esposizione agli attacchi di prompt injection che tentano di esfiltare i segreti tramite l'espansione della shell. Su Linux, questo esegue anche i sottoprocessi Bash in uno spazio dei nomi PID isolato in modo che non possano leggere gli ambienti dei processi host tramite `/proc`; come effetto collaterale, `ps`, `pgrep` e `kill` non possono vedere o segnalare i processi host. `claude-code-action` imposta questo automaticamente quando `allowed_non_write_users` è configurato |

147| `CLAUDE_CODE_SYNC_PLUGIN_INSTALL` | Imposta su `1` in modalità non interattiva (il flag `-p`) per attendere il completamento dell'installazione del plugin prima della prima query. Senza questo, i plugin si installano in background e potrebbero non essere disponibili al primo turno. Combina con `CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS` per limitare l'attesa |153| `CLAUDE_CODE_SYNC_PLUGIN_INSTALL` | Imposta su `1` in modalità non interattiva (il flag `-p`) per attendere il completamento dell'installazione del plugin prima della prima query. Senza questo, i plugin si installano in background e potrebbero non essere disponibili al primo turno. Combina con `CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS` per limitare l'attesa |

148| `CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS` | Timeout in millisecondi per l'installazione sincrona del plugin. Se superato, Claude Code procede senza plugin e registra un errore. Nessun predefinito: senza questa variabile, l'installazione sincrona attende fino al completamento |154| `CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS` | Timeout in millisecondi per l'installazione sincrona del plugin. Se superato, Claude Code procede senza plugin e registra un errore. Nessun predefinito: senza questa variabile, l'installazione sincrona attende fino al completamento |

149| `CLAUDE_CODE_SYNTAX_HIGHLIGHT` | Imposta su `false` per disabilitare l'evidenziazione della sintassi nell'output diff. Utile quando i colori interferiscono con la configurazione del tuo terminale |155| `CLAUDE_CODE_SYNTAX_HIGHLIGHT` | Imposta su `false` per disabilitare l'evidenziazione della sintassi nell'output diff. Utile quando i colori interferiscono con la configurazione del tuo terminale. Per disabilitare anche l'evidenziazione nei blocchi di codice e nelle anteprime di file, utilizza l'impostazione [`syntaxHighlightingDisabled`](/it/settings) |

150| `CLAUDE_CODE_TASK_LIST_ID` | Condividi un elenco di attività tra le sessioni. Imposta lo stesso ID in più istanze di Claude Code per coordinare un elenco di attività condiviso. Vedi [Elenco attività](/it/interactive-mode#task-list) |156| `CLAUDE_CODE_TASK_LIST_ID` | Condividi un elenco di attività tra le sessioni. Imposta lo stesso ID in più istanze di Claude Code per coordinare un elenco di attività condiviso. Vedi [Elenco attività](/it/interactive-mode#task-list) |

151| `CLAUDE_CODE_TEAM_NAME` | Nome del team di agenti a cui appartiene questo compagno di squadra. Impostato automaticamente sui membri del [team di agenti](/it/agent-teams) |157| `CLAUDE_CODE_TEAM_NAME` | Nome del team di agenti a cui appartiene questo compagno di squadra. Impostato automaticamente sui membri del [team di agenti](/it/agent-teams) |

152| `CLAUDE_CODE_TMPDIR` | Sovrascrivi la directory temporanea utilizzata per i file temporanei interni. Claude Code aggiunge `/claude-{uid}/` (Unix) o `/claude/` (Windows) a questo percorso. Predefinito: `/tmp` su macOS, `os.tmpdir()` su Linux/Windows |158| `CLAUDE_CODE_TMPDIR` | Sovrascrivi la directory temporanea utilizzata per i file temporanei interni. Claude Code aggiunge `/claude-{uid}/` (Unix) o `/claude/` (Windows) a questo percorso. Predefinito: `/tmp` su macOS, `os.tmpdir()` su Linux/Windows |

162| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Imposta su `1` per abilitare il watchdog di inattività dello streaming a livello di evento. Disattivato per impostazione predefinita. Per Bedrock, Vertex e Foundry, questo è l'unico watchdog di inattività disponibile. Configura il timeout con `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |168| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Imposta su `1` per abilitare il watchdog di inattività dello streaming a livello di evento. Disattivato per impostazione predefinita. Per Bedrock, Vertex e Foundry, questo è l'unico watchdog di inattività disponibile. Configura il timeout con `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |

163| `CLAUDE_ENV_FILE` | Percorso di uno script di shell i cui contenuti Claude Code esegue prima di ogni comando Bash nello stesso processo di shell, in modo che gli export nel file siano visibili al comando. Utilizza per persistere l'attivazione di virtualenv o conda tra i comandi. Anche popolato dinamicamente dagli hook [SessionStart](/it/hooks#persist-environment-variables), [Setup](/it/hooks#setup), [CwdChanged](/it/hooks#cwdchanged) e [FileChanged](/it/hooks#filechanged) |169| `CLAUDE_ENV_FILE` | Percorso di uno script di shell i cui contenuti Claude Code esegue prima di ogni comando Bash nello stesso processo di shell, in modo che gli export nel file siano visibili al comando. Utilizza per persistere l'attivazione di virtualenv o conda tra i comandi. Anche popolato dinamicamente dagli hook [SessionStart](/it/hooks#persist-environment-variables), [Setup](/it/hooks#setup), [CwdChanged](/it/hooks#cwdchanged) e [FileChanged](/it/hooks#filechanged) |

164| `CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX` | Prefisso per i nomi delle sessioni [Remote Control](/it/remote-control) generati automaticamente quando non viene fornito un nome esplicito. Per impostazione predefinita il nome host della tua macchina, producendo nomi come `myhost-graceful-unicorn`. Il flag CLI `--remote-control-session-name-prefix` imposta lo stesso valore per una singola invocazione |170| `CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX` | Prefisso per i nomi delle sessioni [Remote Control](/it/remote-control) generati automaticamente quando non viene fornito un nome esplicito. Per impostazione predefinita il nome host della tua macchina, producendo nomi come `myhost-graceful-unicorn`. Il flag CLI `--remote-control-session-name-prefix` imposta lo stesso valore per una singola invocazione |

165| `CLAUDE_STREAM_IDLE_TIMEOUT_MS` | Timeout in millisecondi prima che il watchdog di inattività dello streaming chiuda una connessione bloccata. Predefinito e minimo `300000` (5 minuti) per il watchdog a livello di byte sull'API Anthropic; i valori inferiori vengono silenziosamente limitati per assorbire le pause di thinking esteso e il buffering del proxy. Per il watchdog a livello di evento: predefinito `90000` (90 secondi), nessun minimo. Per i provider di terze parti, richiede `CLAUDE_ENABLE_STREAM_WATCHDOG=1` |171| `CLAUDE_STREAM_IDLE_TIMEOUT_MS` | Timeout in millisecondi prima che il watchdog di inattività dello streaming chiuda una connessione bloccata. Predefinito e minimo `300000` (5 minuti) per il watchdog a livello di byte e il watchdog a livello di evento; i valori inferiori vengono silenziosamente limitati per assorbire le pause di thinking esteso e il buffering del proxy. Per i provider di terze parti, richiede `CLAUDE_ENABLE_STREAM_WATCHDOG=1` |

166| `DISABLE_AUTOUPDATER` | Imposta su `1` per disabilitare gli aggiornamenti automatici in background. Il manuale `claude update` funziona ancora. Utilizza `DISABLE_UPDATES` per bloccare entrambi |172| `DISABLE_AUTOUPDATER` | Imposta su `1` per disabilitare gli aggiornamenti automatici in background. Il manuale `claude update` funziona ancora. Utilizza `DISABLE_UPDATES` per bloccare entrambi |

167| `DISABLE_AUTO_COMPACT` | Imposta su `1` per disabilitare la compattazione automatica quando ci si avvicina al limite del contesto. Il comando manuale `/compact` rimane disponibile. Utilizza quando desideri un controllo esplicito su quando si verifica la compattazione |173| `DISABLE_AUTO_COMPACT` | Imposta su `1` per disabilitare la compattazione automatica quando ci si avvicina al limite del contesto. Il comando manuale `/compact` rimane disponibile. Utilizza quando desideri un controllo esplicito su quando si verifica la compattazione |

168| `DISABLE_COMPACT` | Imposta su `1` per disabilitare tutta la compattazione: sia la compattazione automatica che il comando manuale `/compact` |174| `DISABLE_COMPACT` | Imposta su `1` per disabilitare tutta la compattazione: sia la compattazione automatica che il comando manuale `/compact` |

184| `DISABLE_TELEMETRY` | Imposta su `1` per rinunciare alla telemetria Statsig (nota che gli eventi Statsig non includono dati utente come codice, percorsi di file o comandi bash) |190| `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 |

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

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

198| `MAX_STRUCTURED_OUTPUT_RETRIES` | Numero di volte per riprovare quando la risposta del modello non supera la convalida rispetto a [`--json-schema`](/it/cli-reference#cli-flags) in modalità non interattiva (il flag `-p`). Per impostazione predefinita 5 |204| `MAX_STRUCTURED_OUTPUT_RETRIES` | Numero di volte per riprovare quando la risposta del modello non supera la convalida rispetto a [`--json-schema`](/it/cli-reference#cli-flags) in modalità non interattiva (il flag `-p`). Per impostazione predefinita 5 |

199| `MAX_THINKING_TOKENS` | Sovrascrivi il budget del token di [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). Il massimale è il [max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) del modello meno uno. Imposta su `0` per disabilitare completamente il thinking. Sui modelli con [ragionamento adattivo](/it/model-config#adjust-effort-level), il budget viene ignorato a meno che il ragionamento adattivo non sia disabilitato tramite `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |205| `MAX_THINKING_TOKENS` | Sovrascrivi il budget del token di [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). Il massimale è il [max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) del modello meno uno. Imposta su `0` per disabilitare completamente il thinking. Sui modelli con [ragionamento adattivo](/it/model-config#adjust-effort-level), il budget viene ignorato a meno che il ragionamento adattivo non sia disabilitato tramite `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |

200| `MCP_CLIENT_SECRET` | Segreto client OAuth per i server MCP che richiedono [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials). Evita il prompt interattivo quando si aggiunge un server con `--client-secret` |206| `MCP_CLIENT_SECRET` | Segreto client OAuth per i server MCP che richiedono [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials). Evita il prompt interattivo quando si aggiunge un server con `--client-secret` |

201| `MCP_CONNECTION_NONBLOCKING` | Imposta su `true` in modalità non interattiva (`-p`) per saltare completamente l'attesa della connessione MCP. Utile per pipeline con script in cui gli strumenti MCP non sono necessari. Senza questa variabile, la prima query attende fino a 5 secondi per le connessioni del server `--mcp-config` |207| `MCP_CONNECTION_NONBLOCKING` | Imposta su `true` in modalità non interattiva (`-p`) per saltare completamente l'attesa della connessione MCP. Utile per pipeline con script in cui gli strumenti MCP non sono necessari. Senza questa variabile, la prima query attende fino a 5 secondi per le connessioni del server `--mcp-config`. I server configurati con [`alwaysLoad: true`](/it/mcp#exempt-a-server-from-deferral) bloccano sempre l'avvio indipendentemente da questa variabile, poiché i loro strumenti devono essere presenti quando viene costruito il primo prompt |

202| `MCP_OAUTH_CALLBACK_PORT` | Porta fissa per il callback di reindirizzamento OAuth, come alternativa a `--callback-port` quando si aggiunge un server MCP con [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials) |208| `MCP_OAUTH_CALLBACK_PORT` | Porta fissa per il callback di reindirizzamento OAuth, come alternativa a `--callback-port` quando si aggiunge un server MCP con [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials) |

203| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP remoti (HTTP/SSE) da connettere in parallelo durante l'avvio (predefinito: 20) |209| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP remoti (HTTP/SSE) da connettere in parallelo durante l'avvio (predefinito: 20) |

204| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP locali (stdio) da connettere in parallelo durante l'avvio (predefinito: 3) |210| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP locali (stdio) da connettere in parallelo durante l'avvio (predefinito: 3) |

errors.md +27 −5

Details

38| `403` con `x-deny-reason: host_not_allowed` in una sessione cloud o routine | [Rete](#host-not-allowed-in-a-cloud-session) |

282 283

283## Errori di rete e connessione284## Errori di rete e connessione

284 285

285Questi errori significano che Claude Code non poteva raggiungere l'API affatto. Provengono quasi sempre dalla tua rete locale, proxy o firewall piuttosto che dall'infrastruttura Anthropic.286Questi errori significano che una richiesta di rete da Claude Code non è riuscita a raggiungere la sua destinazione. Di solito provengono dalla tua rete locale, proxy o firewall, o dalla politica di rete dell'ambiente cloud.

286 287

287### Unable to connect to API288### Unable to connect to API

288 289

307* Assicurati che il tuo firewall consenta gli host elencati in [Network access requirements](/it/network-config#network-access-requirements)308* Assicurati che il tuo firewall consenta gli host elencati in [Network access requirements](/it/network-config#network-access-requirements)

308* I guasti intermittenti vengono [ritentati automaticamente](#automatic-retries); i guasti persistenti indicano un problema di rete locale309* I guasti intermittenti vengono [ritentati automaticamente](#automatic-retries); i guasti persistenti indicano un problema di rete locale

309 310

310Se `curl` ha successo ma Claude Code ancora fallisce, la causa è solitamente qualcosa tra Node.js e la rete piuttosto che la rete stessa:311Se `curl` ha successo ma Claude Code ancora fallisce, la causa è solitamente qualcosa tra il runtime e la rete piuttosto che la rete stessa:

311 312

312* Su Linux e WSL, controlla `/etc/resolv.conf` per un nameserver irraggiungibile. WSL in particolare può ereditare un resolver rotto dall'host.313* Su Linux e WSL, controlla `/etc/resolv.conf` per un nameserver irraggiungibile. WSL in particolare può ereditare un resolver rotto dall'host.

313* Su macOS, un client VPN che è stato disconnesso o disinstallato può lasciare dietro un'interfaccia tunnel o una regola di routing. Controlla `ifconfig` per interfacce `utun` obsolete e rimuovi l'estensione di rete della VPN in Impostazioni di Sistema.314* Su macOS, un client VPN che è stato disconnesso o disinstallato può lasciare dietro un'interfaccia tunnel o una regola di routing. Controlla `ifconfig` per interfacce `utun` obsolete e rimuovi l'estensione di rete della VPN in Impostazioni di Sistema.

315 316

316### SSL certificate errors317### SSL certificate errors

317 318

318Un proxy o un'appliance di sicurezza sulla tua rete sta intercettando il traffico TLS con il suo certificato, e Node.js non lo considera attendibile.319Un proxy o un'appliance di sicurezza sulla tua rete sta intercettando il traffico TLS con il suo certificato, e Claude Code non lo considera attendibile.

319 320

320```text theme={null}321```text theme={null}

321Unable to connect to API: SSL certificate verification failed. Check your proxy or corporate SSL certificates322Unable to connect to API: SSL certificate verification failed. Check your proxy or corporate SSL certificates

324 325

325**Cosa fare:**326**Cosa fare:**

326 327

327* Esporta il bundle CA della tua organizzazione e punta Node ad esso con `NODE_EXTRA_CA_CERTS=/path/to/ca-bundle.pem`328* Esporta il bundle CA della tua organizzazione e punta Claude Code ad esso con `NODE_EXTRA_CA_CERTS=/path/to/ca-bundle.pem`

328* Vedi [Network configuration](/it/network-config#custom-ca-certificates) per le istruzioni di configurazione complete329* Vedi [Network configuration](/it/network-config#custom-ca-certificates) per le istruzioni di configurazione complete

329* Non impostare `NODE_TLS_REJECT_UNAUTHORIZED=0`, che disabilita completamente la convalida del certificato330* Non impostare `NODE_TLS_REJECT_UNAUTHORIZED=0`, che disabilita completamente la convalida del certificato

330 331

332### Host not allowed in a cloud session

333

334Una richiesta HTTP in uscita da una sessione cloud o routine è stata bloccata dalla politica di rete dell'ambiente.

335

336```text theme={null}

337HTTP 403

338x-deny-reason: host_not_allowed

339```

340

341Potresti anche vedere un certificato TLS che non corrisponde al certificato reale della destinazione. L'ambiente cloud instrada il traffico in uscita attraverso un proxy che applica la politica di rete, quindi un certificato non corrispondente significa che il proxy ha terminato la connessione, non la destinazione.

342

343Questo non è un problema di rete lato client. Le sessioni cloud e le [routine](/it/routines) vengono eseguite all'interno di un ambiente sandbox la cui rete in uscita è filtrata in base alla lista di autorizzazione dell'ambiente. L'ambiente **Default** utilizza l'accesso **Trusted**, che consente la [lista di autorizzazione predefinita](/it/claude-code-on-the-web#default-allowed-domains) dei registri di pacchetti, API dei provider cloud, registri di container e domini di sviluppo comuni, ma blocca tutto il resto.

344

345**Cosa fare:**

346

347* Apri la routine per la modifica, o avvia una sessione cloud. Seleziona l'icona cloud che mostra il nome del tuo ambiente, ad esempio **Default**, per aprire il selettore. Passa il mouse sopra il tuo ambiente e fai clic sull'icona delle impostazioni.

348* Nella finestra di dialogo **Update cloud environment**, cambia **Network access** da **Trusted** a **Custom**, quindi aggiungi il dominio bloccato a **Allowed domains**. Inserisci un dominio per riga. Seleziona **Also include default list of common package managers** per mantenere la [lista di autorizzazione predefinita](/it/claude-code-on-the-web#default-allowed-domains) insieme ai tuoi domini personalizzati. Seleziona **Full** invece se desideri un accesso senza restrizioni.

349* Fai clic su **Save changes**. La prossima esecuzione utilizza la lista di autorizzazione aggiornata.

350

351Vedi [Network access](/it/claude-code-on-the-web#network-access) per i livelli di accesso e la lista di autorizzazione predefinita. Le sessioni CLI locali non sono interessate da questa politica.

352

331## Errori di richiesta353## Errori di richiesta

332 354

333Questi errori significano che l'API ha ricevuto la tua richiesta ma ha rifiutato il suo contenuto.355Questi errori significano che l'API ha ricevuto la tua richiesta ma ha rifiutato il suo contenuto.

487**Cosa fare:**509**Cosa fare:**

488 510

489* Abbassa `MAX_THINKING_TOKENS`, o aumenta [`CLAUDE_CODE_MAX_OUTPUT_TOKENS`](/it/env-vars) sopra il budget di thinking511* Abbassa `MAX_THINKING_TOKENS`, o aumenta [`CLAUDE_CODE_MAX_OUTPUT_TOKENS`](/it/env-vars) sopra il budget di thinking

490* Vedi [Extended thinking](/it/common-workflows#use-extended-thinking-thinking-mode) per come il budget interagisce con la lunghezza dell'output512* Vedi [Extended thinking](/it/model-config#extended-thinking) per come il budget interagisce con la lunghezza dell'output

491 513

492### Tool use or thinking block mismatch514### Tool use or thinking block mismatch

493 515

features-overview.md +2 −2

Details

221 221

222\*Per impostazione predefinita, le descrizioni delle skills si caricano all'inizio della sessione in modo che Claude possa decidere quando utilizzarle. Impostate `disable-model-invocation: true` nel frontmatter di una skill per nasconderla completamente a Claude fino a quando non la invocate manualmente. Questo riduce il costo del contesto a zero per le skills che invocate solo voi.222\*Per impostazione predefinita, le descrizioni delle skills si caricano all'inizio della sessione in modo che Claude possa decidere quando utilizzarle. Impostate `disable-model-invocation: true` nel frontmatter di una skill per nasconderla completamente a Claude fino a quando non la invocate manualmente. Questo riduce il costo del contesto a zero per le skills che invocate solo voi. Per una skill che non avete scritto, impostate [`skillOverrides`](/it/skills#override-skill-visibility-from-settings) nelle impostazioni per fare lo stesso senza modificare il suo file.

223 223

224### Comprendete come le funzionalità si caricano224### Comprendete come le funzionalità si caricano

225 225

282 </Tab>282 </Tab>

283 283

284 <Tab title="Hooks">284 <Tab title="Hooks">

285 **Quando:** Al trigger. Gli hooks si attivano su eventi del ciclo di vita specifici come esecuzione dello strumento, confini della sessione, invio del prompt, richieste di autorizzazione e compattazione. Consultate [Hooks](/it/hooks-guide) per l'elenco completo.285 **Quando:** Al trigger. Gli hooks si attivano su eventi del ciclo di vita specifici come esecuzione dello strumento, confini della sessione, invio del prompt, richieste di autorizzazione e compattazione. Consultate [Hooks](/it/hooks) per l'elenco completo.

286 286

287 **Cosa si carica:** Niente per impostazione predefinita. Gli hooks vengono eseguiti al di fuori della conversazione principale.287 **Cosa si carica:** Niente per impostazione predefinita. Gli hooks vengono eseguiti al di fuori della conversazione principale.

288 288

fullscreen.md +10 −2

Details

93 93

94Un valore di `3` corrisponde al valore predefinito in `vim` e applicazioni simili. L'impostazione accetta valori da 1 a 20.94Un valore di `3` corrisponde al valore predefinito in `vim` e applicazioni simili. L'impostazione accetta valori da 1 a 20.

95 95

96### Scorrimento nel terminale dell'IDE JetBrains

98Nel terminale dell'IDE JetBrains, Claude Code applica la propria gestione dello scorrimento e ignora `CLAUDE_CODE_SCROLL_SPEED`. Il terminale invia eventi di scorrimento a una velocità molto più elevata rispetto ad altri emulatori, quindi un moltiplicatore sintonizzato altrove va oltre qui.

100Nel 2025.2, il terminale ha anche bug di scorrimento con la rotella che producono tasti freccia spuri e eventi di direzione sbagliata. Claude Code rileva questi in fase di esecuzione e li mitiga automaticamente, quindi lo scorrimento con trackpad e rotella del mouse funzionano senza configurazione. Per la migliore esperienza di scorrimento, esegui l'aggiornamento a 2025.3 o versioni successive. Claude Code mostra un suggerimento la prima volta che scorri se rileva il bug.

101

96## Cerca e rivedi la conversazione102## Cerca e rivedi la conversazione

97 103

98`Ctrl+o` attiva/disattiva tra il prompt normale e la modalità trascrizione. Per una vista più silenziosa che mostra solo l'ultimo prompt, un riassunto di una riga delle chiamate dello strumento con diffstat di modifica e la risposta finale, esegui `/focus`. L'impostazione persiste tra le sessioni. Esegui `/focus` di nuovo per disattivarla.104`Ctrl+o` attiva/disattiva tra il prompt normale e la modalità trascrizione. Per una vista più silenziosa che mostra solo l'ultimo prompt, un riassunto di una riga delle chiamate dello strumento con diffstat di modifica e la risposta finale, esegui `/focus`. L'impostazione persiste tra le sessioni. Esegui `/focus` di nuovo per disattivarla.

122 128

123## Usa con tmux129## Usa con tmux

124 130

125Il rendering a schermo intero funziona all'interno di tmux, con due avvertenze.131Il rendering a schermo intero funziona all'interno di tmux, con tre avvertenze.

126 132

127Lo scorrimento con la rotella del mouse richiede la modalità mouse di tmux. Se il tuo `~/.tmux.conf` non lo abilita già, aggiungi questa riga e ricarica la configurazione:133Lo scorrimento con la rotella del mouse richiede la modalità mouse di tmux. Se il tuo `~/.tmux.conf` non lo abilita già, aggiungi questa riga e ricarica la configurazione:

128 134

134 140

135Il rendering a schermo intero è incompatibile con la modalità di integrazione tmux di iTerm2, che è la modalità in cui entri con `tmux -CC`. In modalità integrazione, iTerm2 renderizza ogni riquadro tmux come una divisione nativa piuttosto che lasciare che tmux disegni sul terminale. Il buffer dello schermo alternativo e il tracciamento del mouse non funzionano correttamente lì: la rotella del mouse non fa nulla e il doppio clic può corrompere lo stato del terminale. Non abilitare il rendering a schermo intero nelle sessioni `tmux -CC`. Il tmux regolare all'interno di iTerm2, senza `-CC`, funziona bene.141Il rendering a schermo intero è incompatibile con la modalità di integrazione tmux di iTerm2, che è la modalità in cui entri con `tmux -CC`. In modalità integrazione, iTerm2 renderizza ogni riquadro tmux come una divisione nativa piuttosto che lasciare che tmux disegni sul terminale. Il buffer dello schermo alternativo e il tracciamento del mouse non funzionano correttamente lì: la rotella del mouse non fa nulla e il doppio clic può corrompere lo stato del terminale. Non abilitare il rendering a schermo intero nelle sessioni `tmux -CC`. Il tmux regolare all'interno di iTerm2, senza `-CC`, funziona bene.

136 142

143tmux non supporta l'output sincronizzato, quindi potresti vedere più sfarfallio durante i ridisegni rispetto a quando esegui Claude Code direttamente nel tuo terminale. Se lo sfarfallio è evidente, specialmente su SSH, esegui Claude Code nella sua propria scheda terminale al di fuori di tmux.

144

137## Mantieni la selezione di testo nativa145## Mantieni la selezione di testo nativa

138 146

139L'acquisizione del mouse è il punto di attrito più comune, specialmente su SSH o all'interno di tmux. Quando Claude Code acquisisce gli eventi del mouse, la copia nativa al rilascio della selezione del terminale smette di funzionare. La selezione che fai con clic e trascinamento esiste all'interno di Claude Code, non nel buffer di selezione del terminale, quindi la modalità copia tmux, i suggerimenti Kitty e strumenti simili non la vedono.147L'acquisizione del mouse è il punto di attrito più comune, specialmente su SSH o all'interno di tmux. Quando Claude Code acquisisce gli eventi del mouse, la copia nativa al rilascio della selezione del terminale smette di funzionare. La selezione che fai con clic e trascinamento esiste all'interno di Claude Code, non nel buffer di selezione del terminale, quindi la modalità copia tmux, i suggerimenti Kitty e strumenti simili non la vedono.

156 164

157Se riscontri un problema, esegui `/feedback` all'interno di Claude Code per segnalarlo, o apri un problema nel [repository GitHub di claude-code](https://github.com/anthropics/claude-code/issues). Includi il nome e la versione dell'emulatore del terminale.165Se riscontri un problema, esegui `/feedback` all'interno di Claude Code per segnalarlo, o apri un problema nel [repository GitHub di claude-code](https://github.com/anthropics/claude-code/issues). Includi il nome e la versione dell'emulatore del terminale.

158 166

159Per disattivare il rendering a schermo intero, esegui `/tui default`, o annulla l'impostazione della variabile di ambiente se l'hai abilitata in quel modo.167Per disattivare il rendering a schermo intero, esegui `/tui default`, o annulla l'impostazione di `CLAUDE_CODE_NO_FLICKER` se l'hai abilitata in quel modo. Per forzare il renderer classico indipendentemente dall'impostazione `tui` salvata, imposta `CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1`. Il renderer classico mantiene la conversazione nello scrollback nativo del tuo terminale, quindi `Cmd+f` e la modalità di copia di tmux funzionano come al solito.

google-vertex-ai.md +22 −1

Details

266Claude Code v2.1.121 o versioni successive supporta [X.509 certificate-based Workload Identity Federation](https://cloud.google.com/iam/docs/workload-identity-federation-with-x509-certificates) attraverso la stessa catena Application Default Credentials. Imposta `GOOGLE_APPLICATION_CREDENTIALS` al percorso del tuo file di configurazione delle credenziali.266Claude Code v2.1.121 o versioni successive supporta [X.509 certificate-based Workload Identity Federation](https://cloud.google.com/iam/docs/workload-identity-federation-with-x509-certificates) attraverso la stessa catena Application Default Credentials. Imposta `GOOGLE_APPLICATION_CREDENTIALS` al percorso del tuo file di configurazione delle credenziali.

267 267

268<Note>268<Note>

269 Durante l'autenticazione, Claude Code utilizzerà automaticamente l'ID progetto dalla variabile di ambiente `ANTHROPIC_VERTEX_PROJECT_ID`. Per eseguire l'override, imposta una di queste variabili di ambiente: `GCLOUD_PROJECT`, `GOOGLE_CLOUD_PROJECT` o `GOOGLE_APPLICATION_CREDENTIALS`.269 Claude Code utilizza `ANTHROPIC_VERTEX_PROJECT_ID` come ID progetto per le richieste Vertex AI. Le variabili di ambiente `GCLOUD_PROJECT` e `GOOGLE_CLOUD_PROJECT` e il file di credenziali a cui fa riferimento `GOOGLE_APPLICATION_CREDENTIALS` hanno la precedenza su di esso. Se nessuno di questi è impostato, l'ID progetto viene risolto dalla tua configurazione `gcloud` o dall'account di servizio collegato.

270</Note>270</Note>

271 271

272#### Configurazione avanzata delle credenziali

273

274Claude Code supporta l'aggiornamento automatico delle credenziali GCP tramite l'impostazione `gcpAuthRefresh`. Quando Claude Code rileva che le tue credenziali GCP sono scadute o non possono essere caricate, esegue il comando configurato per ottenere nuove credenziali prima di riprovare la richiesta.

275

276```json theme={null}

277{

278 "gcpAuthRefresh": "gcloud auth application-default login",

279 "env": {

280 "ANTHROPIC_VERTEX_PROJECT_ID": "your-project-id"

281 }

282}

283```

284

285L'output del comando viene visualizzato all'utente, ma l'input interattivo non è supportato. Questo funziona bene per i flussi di autenticazione basati su browser in cui la CLI mostra un URL e completi l'autenticazione nel browser. Il comando di aggiornamento scade dopo tre minuti se l'autenticazione non viene completata. Se imposti `gcpAuthRefresh` nelle impostazioni del progetto come `.claude/settings.json`, il comando viene eseguito solo dopo che accetti il prompt di fiducia dell'area di lavoro.

286

272### 4. Configura Claude Code287### 4. Configura Claude Code

273 288

274Imposta le seguenti variabili di ambiente:289Imposta le seguenti variabili di ambiente:

363 378

364## Risoluzione dei problemi379## Risoluzione dei problemi

365 380

381Se riscontri errori "Could not load the default credentials":

382

383* Esegui `gcloud auth application-default login` per configurare le credenziali predefinite dell'applicazione

384* Imposta `GOOGLE_APPLICATION_CREDENTIALS` su un percorso di file della chiave dell'account di servizio

385* Vedi [Configure GCP credentials](#3-configure-gcp-credentials) per tutte le opzioni

386

366Se riscontri problemi di quota:387Se riscontri problemi di quota:

367 388

368* Controlla le quote attuali o richiedi un aumento della quota tramite [Cloud Console](https://cloud.google.com/docs/quotas/view-manage)389* Controlla le quote attuali o richiedi un aumento della quota tramite [Cloud Console](https://cloud.google.com/docs/quotas/view-manage)

headless.md +33 −3

Details

54| Impostazioni | `--settings <file-or-json>` |54| Impostazioni | `--settings <file-or-json>` |

55| Server MCP | `--mcp-config <file-or-json>` |55| Server MCP | `--mcp-config <file-or-json>` |

56| Agenti personalizzati | `--agents <json>` |56| Agenti personalizzati | `--agents <json>` |

58 58

59La modalità bare salta le letture OAuth e keychain. L'autenticazione Anthropic deve provenire da `ANTHROPIC_API_KEY` o da un `apiKeyHelper` nel JSON passato a `--settings`. Bedrock, Vertex e Foundry utilizzano le loro credenziali provider usuali.59La modalità bare salta le letture OAuth e keychain. L'autenticazione Anthropic deve provenire da `ANTHROPIC_API_KEY` o da un `apiKeyHelper` nel JSON passato a `--settings`. Bedrock, Vertex e Foundry utilizzano le loro credenziali provider usuali.

60 60

66 66

67Questi esempi evidenziano i modelli CLI comuni. Per CI e altre chiamate con script, aggiungi [`--bare`](#start-faster-with-bare-mode) in modo che non raccolgano qualsiasi cosa sia configurata localmente.67Questi esempi evidenziano i modelli CLI comuni. Per CI e altre chiamate con script, aggiungi [`--bare`](#start-faster-with-bare-mode) in modo che non raccolgano qualsiasi cosa sia configurata localmente.

68 68

69### Inviare dati attraverso Claude

71La modalità non interattiva legge stdin, quindi puoi inviare dati e reindirizzare la risposta come qualsiasi altro strumento da riga di comando.

73Questo esempio invia un log di compilazione a Claude e scrive la spiegazione in un file:

75```bash theme={null}

76cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt

77```

79Con `--output-format json`, il payload della risposta include `total_cost_usd` e una suddivisione dei costi per modello, quindi i chiamanti con script possono tracciare la spesa per invocazione senza consultare il [dashboard di utilizzo](/it/costs).

81<Note>

82 A partire da Claude Code v2.1.128, stdin inviato tramite pipe è limitato a 10MB. Se superi il limite, Claude Code esce con un errore chiaro e uno stato diverso da zero. Per lavorare con input più grandi, scrivi il contenuto in un file e fai riferimento al percorso del file nel tuo prompt invece di inviarlo tramite pipe.

83</Note>

85### Aggiungere Claude a uno script di compilazione

87Puoi avvolgere una chiamata non interattiva in uno script per utilizzare Claude come linter o revisore specifico del progetto.

89Questo script `package.json` invia il diff rispetto a `main` a Claude e gli chiede di segnalare i refusi. Inviare il diff tramite pipe significa che Claude non ha bisogno del permesso Bash per leggerlo, e le virgolette doppie sfuggite mantengono lo script portabile su Windows:

91```json theme={null}

92{

93 "scripts": {

94 "lint:claude": "git diff main | claude -p \"you are a typo linter. for each typo in this diff, report filename:line on one line and the issue on the next. return nothing else.\""

95 }

96}

97```

69### Ottenere output strutturato99### Ottenere output strutturato

70 100

71Utilizza `--output-format` per controllare come vengono restituite le risposte:101Utilizza `--output-format` per controllare come vengono restituite le risposte:

137L'evento `system/init` segnala i metadati della sessione inclusi il modello, gli strumenti, i server MCP e i plugin caricati. È il primo evento nel flusso a meno che [`CLAUDE_CODE_SYNC_PLUGIN_INSTALL`](/it/env-vars) non sia impostato, nel qual caso gli eventi `plugin_install` lo precedono. Utilizza i campi plugin per far fallire CI quando un plugin non è stato caricato:167L'evento `system/init` segnala i metadati della sessione inclusi il modello, gli strumenti, i server MCP e i plugin caricati. È il primo evento nel flusso a meno che [`CLAUDE_CODE_SYNC_PLUGIN_INSTALL`](/it/env-vars) non sia impostato, nel qual caso gli eventi `plugin_install` lo precedono. Utilizza i campi plugin per far fallire CI quando un plugin non è stato caricato:

138 168

140| --------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |170| --------------- | ----- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

142| `plugin_errors` | array | errori di caricamento del plugin come una versione di dipendenza non soddisfatta, ognuno con `plugin`, `type` e `message`. I plugin interessati vengono declassati e assenti da `plugins`. La chiave viene omessa quando non ci sono errori |172| `plugin_errors` | array | errori di caricamento del plugin, ognuno con `plugin`, `type` e `message`. Include versioni di dipendenza non soddisfatte e errori di caricamento di `--plugin-dir` come un percorso mancante o un archivio non valido. I plugin interessati vengono declassati e assenti da `plugins`. La chiave viene omessa quando non ci sono errori |

143 173

144Quando [`CLAUDE_CODE_SYNC_PLUGIN_INSTALL`](/it/env-vars) è impostato, Claude Code emette eventi `system/plugin_install` mentre i plugin del marketplace si installano prima del primo turno. Utilizza questi per visualizzare il progresso dell'installazione nella tua interfaccia utente.174Quando [`CLAUDE_CODE_SYNC_PLUGIN_INSTALL`](/it/env-vars) è impostato, Claude Code emette eventi `system/plugin_install` mentre i plugin del marketplace si installano prima del primo turno. Utilizza questi per visualizzare il progresso dell'installazione nella tua interfaccia utente.

145 175

how-claude-code-works.md +9 −15

Details

94 94

95## Lavora con le sessioni95## Lavora con le sessioni

96 96

97Claude Code salva la tua conversazione localmente mentre lavori. Ogni messaggio, utilizzo di strumento e risultato viene archiviato, il che consente [il rewind](#undo-changes-with-checkpoints), [la ripresa e il fork](#resume-or-fork-sessions) delle sessioni. Prima che Claude apporta modifiche al codice, crea anche uno snapshot dei file interessati in modo da poter ripristinare se necessario.97Claude Code salva la tua conversazione localmente mentre lavori. Ogni messaggio, utilizzo di strumento e risultato viene scritto in un file JSONL in testo semplice sotto `~/.claude/projects/`, il che consente [il rewind](#undo-changes-with-checkpoints), [la ripresa e il fork](#resume-or-fork-sessions) delle sessioni. Prima che Claude apporta modifiche al codice, crea anche uno snapshot dei file interessati in modo da poter ripristinare se necessario. Per i percorsi, la conservazione e come cancellare questi dati, consulta [dati dell'applicazione in `~/.claude`](/it/claude-directory#application-data).

98 98

99**Le sessioni sono indipendenti.** Ogni nuova sessione inizia con una finestra di contesto fresca, senza la cronologia della conversazione dalle sessioni precedenti. Claude può persistere gli apprendimenti tra le sessioni utilizzando [auto memory](/it/memory#auto-memory) e puoi aggiungere le tue istruzioni persistenti in [CLAUDE.md](/it/memory).99**Le sessioni sono indipendenti.** Ogni nuova sessione inizia con una finestra di contesto fresca, senza la cronologia della conversazione dalle sessioni precedenti. Claude può persistere gli apprendimenti tra le sessioni utilizzando [auto memory](/it/memory#auto-memory) e puoi aggiungere le tue istruzioni persistenti in [CLAUDE.md](/it/memory).

100 100

101### Lavora tra i rami101### Lavora tra i rami

102 102

103Ogni conversazione di Claude Code è una sessione legata alla tua directory corrente. Quando riprendi, vedi solo le sessioni da quella directory.103Ogni conversazione di Claude Code è una sessione legata alla tua directory corrente. Il picker `/resume` mostra sessioni dal worktree corrente per impostazione predefinita, con scorciatoie da tastiera per ampliare l'elenco ad altri worktrees o progetti. Consulta [Gestisci sessioni](/it/sessions#use-the-session-picker) per l'elenco completo delle scorciatoie del picker e come funziona la risoluzione dei nomi.

104 104

105Claude vede i file del tuo ramo corrente. Quando cambi ramo, Claude vede i file del nuovo ramo, ma la cronologia della tua conversazione rimane la stessa. Claude ricorda quello che hai discusso anche dopo il cambio di ramo.105Claude vede i file del tuo ramo corrente. Quando cambi ramo, Claude vede i file del nuovo ramo, ma la cronologia della tua conversazione rimane la stessa. Claude ricorda quello che hai discusso anche dopo il cambio di ramo.

106 106

107Poiché le sessioni sono legate alle directory, puoi eseguire sessioni Claude parallele utilizzando [git worktrees](/it/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees), che creano directory separate per singoli rami.107Poiché le sessioni sono legate alle directory, puoi eseguire sessioni Claude parallele utilizzando [git worktrees](/it/worktrees), che creano directory separate per singoli rami.

108 108

109### Riprendi o fai il fork delle sessioni109### Riprendi o fai il fork delle sessioni

110 110

111Quando riprendi una sessione con `claude --continue` o `claude --resume`, riprendi da dove hai lasciato utilizzando lo stesso ID di sessione. I nuovi messaggi si aggiungono alla conversazione esistente. La tua cronologia completa della conversazione viene ripristinata, ma i permessi con ambito di sessione non lo sono. Dovrai approvarli di nuovo.111Riprendere una sessione con `claude --continue` o `claude --resume` la riapre con lo stesso ID di sessione e aggiunge nuovi messaggi alla conversazione esistente. Fare il fork con `--fork-session` o `/branch` copia la cronologia in un nuovo ID di sessione, lasciando l'originale invariato.

112 112

113<img src="https://mintcdn.com/claude-code/c5r9_6tjPMzFdDDT/images/session-continuity.svg?fit=max&auto=format&n=c5r9_6tjPMzFdDDT&q=85&s=fa41d12bfb57579cabfeece907151d30" alt="Continuità della sessione: resume continua la stessa sessione, fork crea un nuovo ramo con un nuovo ID." width="560" height="280" data-path="images/session-continuity.svg" />113<img src="https://mintcdn.com/claude-code/c5r9_6tjPMzFdDDT/images/session-continuity.svg?fit=max&auto=format&n=c5r9_6tjPMzFdDDT&q=85&s=fa41d12bfb57579cabfeece907151d30" alt="Continuità della sessione: resume continua la stessa sessione, fork crea un nuovo ramo con un nuovo ID." width="560" height="280" data-path="images/session-continuity.svg" />

114 114

115Per creare un ramo e provare un approccio diverso senza influenzare la sessione originale, utilizza il flag `--fork-session`:115Per i flag di ripresa, il picker `/resume`, la denominazione e cosa succede quando la stessa sessione è aperta in due terminali, consulta [Gestisci sessioni](/it/sessions).

~~116~~

117```bash theme={null}

118claude --continue --fork-session

119```

~~120~~

121Questo crea un nuovo ID di sessione preservando la cronologia della conversazione fino a quel punto. La sessione originale rimane invariata. Come resume, le sessioni forkate non ereditano i permessi con ambito di sessione.

~~122~~

123**Stessa sessione in più terminali**: Se riprendi la stessa sessione in più terminali, entrambi i terminali scrivono nello stesso file di sessione. I messaggi da entrambi vengono intercalati, come due persone che scrivono nello stesso quaderno. Nulla si corrompe, ma la conversazione diventa confusa. Ogni terminale vede solo i suoi messaggi durante la sessione, ma se riprendi quella sessione in seguito, vedrai tutto intercalato. Per il lavoro parallelo dallo stesso punto di partenza, utilizza `--fork-session` per dare a ogni terminale la sua sessione pulita.

124 116

125### La finestra di contesto117### La finestra di contesto

126 118

134 126

135Per controllare cosa viene preservato durante la compattazione, aggiungi una sezione "Compact Instructions" a CLAUDE.md o esegui `/compact` con un focus (come `/compact focus on the API changes`).127Per controllare cosa viene preservato durante la compattazione, aggiungi una sezione "Compact Instructions" a CLAUDE.md o esegui `/compact` con un focus (come `/compact focus on the API changes`).

136 128

129Se un singolo file o output di strumento è così grande che il contesto si riempie immediatamente dopo ogni riassunto, Claude Code smette di compattare automaticamente dopo alcuni tentativi e mostra un errore invece di fare un ciclo. Consulta [Auto-compaction stops with a thrashing error](/it/troubleshooting#auto-compaction-stops-with-a-thrashing-error) per i passaggi di recupero.

130

137Esegui `/context` per vedere cosa sta usando lo spazio. Le definizioni degli strumenti MCP vengono differite per impostazione predefinita e caricate su richiesta tramite [ricerca degli strumenti](/it/mcp#scale-with-mcp-tool-search), quindi solo i nomi degli strumenti consumano contesto fino a quando Claude utilizza uno strumento specifico. Esegui `/mcp` per controllare i costi per server.131Esegui `/context` per vedere cosa sta usando lo spazio. Le definizioni degli strumenti MCP vengono differite per impostazione predefinita e caricate su richiesta tramite [ricerca degli strumenti](/it/mcp#scale-with-mcp-tool-search), quindi solo i nomi degli strumenti consumano contesto fino a quando Claude utilizza uno strumento specifico. Esegui `/mcp` per controllare i costi per server.

138 132

139#### Gestisci il contesto con skills e subagents133#### Gestisci il contesto con skills e subagents

140 134

141Oltre alla compattazione, puoi utilizzare altre funzionalità per controllare cosa viene caricato nel contesto.135Oltre alla compattazione, puoi utilizzare altre funzionalità per controllare cosa viene caricato nel contesto.

142 136

143[Skills](/it/skills) si caricano su richiesta. Claude vede le descrizioni delle skills all'inizio della sessione, ma il contenuto completo si carica solo quando una skill viene utilizzata. Per le skills che invochi manualmente, imposta `disable-model-invocation: true` per mantenere le descrizioni fuori dal contesto fino a quando non ne hai bisogno.137[Skills](/it/skills) si caricano su richiesta. Claude vede le descrizioni delle skills all'inizio della sessione, ma il contenuto completo si carica solo quando una skill viene utilizzata. Per le skills che invochi manualmente, imposta `disable-model-invocation: true` per mantenere le descrizioni fuori dal contesto fino a quando non ne hai bisogno. Per le skills che non hai scritto, utilizza [`skillOverrides`](/it/skills#override-skill-visibility-from-settings) per fare lo stesso dalle impostazioni.

144 138

145[Subagents](/it/sub-agents) ottengono il loro contesto fresco, completamente separato dalla tua conversazione principale. Il loro lavoro non gonfia il tuo contesto. Quando finito, restituiscono un riassunto. Questo isolamento è il motivo per cui i subagents aiutano con le sessioni lunghe.139[Subagents](/it/sub-agents) ottengono il loro contesto fresco, completamente separato dalla tua conversazione principale. Il loro lavoro non gonfia il tuo contesto. Quando finito, restituiscono un riassunto. Questo isolamento è il motivo per cui i subagents aiutano con le sessioni lunghe.

146 140

161Premi `Shift+Tab` per scorrere le modalità di permesso:155Premi `Shift+Tab` per scorrere le modalità di permesso:

162 156

163* **Predefinito**: Claude chiede prima delle modifiche ai file e dei comandi shell157* **Predefinito**: Claude chiede prima delle modifiche ai file e dei comandi shell

164* **Auto-accept edits**: Claude modifica i file senza chiedere, chiede ancora per i comandi158* **Auto-accept edits**: Claude modifica i file ed esegue comandi comuni del file system come `mkdir` e `mv` senza chiedere, chiede ancora per altri comandi

165* **Plan Mode**: Claude utilizza solo strumenti di sola lettura, creando un piano che puoi approvare prima dell'esecuzione159* **Plan Mode**: Claude utilizza solo strumenti di sola lettura, creando un piano che puoi approvare prima dell'esecuzione

166* **Auto mode**: Claude valuta tutte le azioni con controlli di sicurezza in background. Attualmente un'anteprima di ricerca160* **Auto mode**: Claude valuta tutte le azioni con controlli di sicurezza in background. Attualmente un'anteprima di ricerca

167 161

interactive-mode.md +6 −5

Details

11<Note>11<Note>

12 Le scorciatoie da tastiera possono variare a seconda della piattaforma e del terminale. Premere `?` per visualizzare le scorciatoie disponibili per il vostro ambiente.12 Le scorciatoie da tastiera possono variare a seconda della piattaforma e del terminale. Premere `?` per visualizzare le scorciatoie disponibili per il vostro ambiente.

13 13

~~14 **Utenti macOS**: Le scorciatoie con il tasto Option/Alt (`Alt+B`, `Alt+F`, `Alt+Y`, `Alt+M`, `Alt+P`, `Alt+T`) richiedono la configurazione di Option come Meta nel vostro terminale:~~14 **Utenti macOS**: Le scorciatoie con il tasto Option/Alt (`Alt+B`, `Alt+F`, `Alt+Y`, `Alt+M`, `Alt+P`) richiedono la configurazione di Option come Meta nel vostro terminale:

15 15

16 * **iTerm2**: Impostazioni → Profili → Tasti → Generale → impostare il tasto Option sinistro/destro su "Esc+"16 * **iTerm2**: Impostazioni → Profili → Tasti → Generale → impostare il tasto Option sinistro/destro su "Esc+"

17 * **Apple Terminal**: Impostazioni → Profili → Tastiera → selezionare "Usa Option come Meta Key"17 * **Apple Terminal**: Impostazioni → Profili → Tastiera → selezionare "Usa Option come Meta Key"

40| `Shift+Tab` o `Alt+M` (alcune configurazioni) | Cicla le modalità di permesso | Cicla attraverso `default`, `acceptEdits`, `plan` e qualsiasi modalità abilitata, come `auto` o `bypassPermissions`. Vedere [modalità di permesso](/it/permission-modes). |40| `Shift+Tab` o `Alt+M` (alcune configurazioni) | Cicla le modalità di permesso | Cicla attraverso `default`, `acceptEdits`, `plan` e qualsiasi modalità abilitata, come `auto` o `bypassPermissions`. Vedere [modalità di permesso](/it/permission-modes). |

42| `Option+T` (macOS) o `Alt+T` (Windows/Linux) | Attiva/disattiva il pensiero esteso | Abilita o disabilita la modalità di pensiero esteso. Su macOS, configurare il vostro terminale per inviare Option come Meta affinché questa scorciatoia funzioni |42| `Option+T` (macOS) o `Alt+T` (Windows/Linux) | Attiva/disattiva il pensiero esteso | Abilita o disabilita la modalità di pensiero esteso. A partire dalla v2.1.132 questa scorciatoia funziona su macOS senza configurare Option come Meta |

44 44

45### Modifica del testo45### Modifica del testo

68| :-------------------- | :------------------- | :-------------------------------------------------------------------------------------------------------- |68| :-------------------- | :------------------- | :-------------------------------------------------------------------------------------------------------- |

74 74

75<Tip>75<Tip>

76 Shift+Enter funziona senza configurazione in iTerm2, WezTerm, Ghostty, Kitty, Warp e Apple Terminal. Per VS Code, Cursor, Windsurf, Alacritty e Zed, eseguire `/terminal-setup` per installare il binding.76 Shift+Enter funziona senza configurazione in iTerm2, WezTerm, Ghostty, Kitty, Warp, Apple Terminal e Windows Terminal. Per VS Code, Cursor, Windsurf, Alacritty e Zed, eseguire `/terminal-setup` per installare il binding.

77</Tip>77</Tip>

78 78

79### Comandi rapidi79### Comandi rapidi

130| Comando | Azione |130| Comando | Azione |

131| :-------------- | :--------------------------------------------------------- |131| :-------------- | :--------------------------------------------------------- |

133| `Space` | Sposta a destra |

133| `w` | Parola successiva |134| `w` | Parola successiva |

134| `e` | Fine della parola |135| `e` | Fine della parola |

135| `b` | Parola precedente |136| `b` | Parola precedente |

2201. **Avvia ricerca**: premete `Ctrl+R` per attivare la ricerca inversa nella cronologia2211. **Avvia ricerca**: premete `Ctrl+R` per attivare la ricerca inversa nella cronologia

2212. **Digita query**: inserite il testo da cercare nei comandi precedenti. Il termine di ricerca è evidenziato nei risultati corrispondenti2222. **Digita query**: inserite il testo da cercare nei comandi precedenti. Il termine di ricerca è evidenziato nei risultati corrispondenti

2223. **Naviga tra i risultati**: premete `Ctrl+R` di nuovo per scorrere i risultati più vecchi2233. **Naviga tra i risultati**: premete `Ctrl+R` di nuovo per scorrere i risultati più vecchi

2234. **Cambia ambito**: premete `Ctrl+S` per alternare tra questa sessione, questo progetto e tutti i progetti2244. **Cambia ambito**: la ricerca è impostata per impostazione predefinita su prompt da tutti i progetti. Premete `Ctrl+S` per alternare l'ambito tra questa sessione, questo progetto e tutti i progetti

2245. **Accetta il risultato**:2255. **Accetta il risultato**:

225 * Premete `Tab` o `Esc` per accettare il risultato corrente e continuare a modificare226 * Premete `Tab` o `Esc` per accettare il risultato corrente e continuare a modificare

226 * Premete `Enter` per accettare ed eseguire il comando immediatamente227 * Premete `Enter` per accettare ed eseguire il comando immediatamente

llm-gateway.md +1 −1

Details

53 53

54Per impostazione predefinita, Claude Code utilizza nomi di modelli standard per il formato API selezionato.54Per impostazione predefinita, Claude Code utilizza nomi di modelli standard per il formato API selezionato.

55 55

56Quando `ANTHROPIC_BASE_URL` punta a un gateway che espone il formato Anthropic Messages, Claude Code interroga l'endpoint `/v1/models` del gateway all'avvio e aggiunge i modelli restituiti al selettore `/model`. Ogni voce scoperta è etichettata "From gateway" e utilizza il campo `display_name` dalla risposta quando fornito. Ciò richiede Claude Code v2.1.126 o successivo.56Quando `ANTHROPIC_BASE_URL` punta a un gateway che espone il formato Anthropic Messages, Claude Code interroga l'endpoint `/v1/models` del gateway all'avvio e aggiunge i modelli restituiti al selettore `/model`. Impostare `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1` per abilitare questa funzionalità. La scoperta è disabilitata per impostazione predefinita in modo che i gateway supportati da una chiave API condivisa non espongano ogni modello a cui la chiave può accedere a ogni utente. Ogni voce scoperta è etichettata "From gateway" e utilizza il campo `display_name` dalla risposta quando fornito. Ciò richiede Claude Code v2.1.129 o successivo.

57 57

58La scoperta si applica solo al formato Anthropic Messages. Non viene eseguita per gli endpoint pass-through Bedrock o Vertex e non viene eseguita quando `ANTHROPIC_BASE_URL` non è impostato o punta a `api.anthropic.com`.58La scoperta si applica solo al formato Anthropic Messages. Non viene eseguita per gli endpoint pass-through Bedrock o Vertex e non viene eseguita quando `ANTHROPIC_BASE_URL` non è impostato o punta a `api.anthropic.com`.

59 59

mcp.md +12 −2

Details

327/mcp327/mcp

328```328```

329 329

330Il pannello `/mcp` mostra il conteggio degli strumenti accanto a ogni server connesso e contrassegna i server che pubblicizzano la capacità degli strumenti ma non espongono alcuno strumento.

331

332Il nome del server `workspace` è riservato per uso interno. Se la tua configurazione definisce un server con quel nome, Claude Code lo salta al momento del caricamento e mostra un avviso chiedendoti di rinominarlo.

333

330### Aggiornamenti dinamici degli strumenti334### Aggiornamenti dinamici degli strumenti

331 335

332Claude Code supporta le notifiche `list_changed` di MCP, consentendo ai server MCP di aggiornare dinamicamente i loro strumenti, prompt e risorse disponibili senza richiedere di disconnettersi e riconnettersi. Quando un server MCP invia una notifica `list_changed`, Claude Code aggiorna automaticamente le capacità disponibili da quel server.336Claude Code supporta le notifiche `list_changed` di MCP, consentendo ai server MCP di aggiornare dinamicamente i loro strumenti, prompt e risorse disponibili senza richiedere di disconnettersi e riconnettersi. Quando un server MCP invia una notifica `list_changed`, Claude Code aggiorna automaticamente le capacità disponibili da quel server.

423 427

424## Ambiti di installazione MCP428## Ambiti di installazione MCP

425 429

426I server MCP possono essere configurati a tre ambiti diversi. L'ambito che scegli controlla in quali progetti il server viene caricato e se la configurazione è condivisa con il tuo team.430I server MCP possono essere configurati a tre ambiti diversi. L'ambito che scegli controlla in quali progetti il server viene caricato e se la configurazione è condivisa con il tuo team. Gli amministratori possono anche distribuire server a livello aziendale tramite [configurazione gestita](#managed-mcp-configuration).

427 431

429| -------------------------- | ------------------------- | ------------------------------------ | ------------------------------------- |433| -------------------------- | ------------------------- | ------------------------------------ | ------------------------------------- |

469I server con ambito del progetto abilitano la collaborazione del team archiviando le configurazioni in un file `.mcp.json` nella directory radice del tuo progetto. Questo file è progettato per essere archiviato nel controllo della versione, assicurando che tutti i membri del team abbiano accesso agli stessi strumenti e servizi MCP. Quando aggiungi un server con ambito del progetto, Claude Code crea o aggiorna automaticamente questo file con la struttura di configurazione appropriata.473I server con ambito del progetto abilitano la collaborazione del team archiviando le configurazioni in un file `.mcp.json` nella directory radice del tuo progetto. Questo file è progettato per essere archiviato nel controllo della versione, assicurando che tutti i membri del team abbiano accesso agli stessi strumenti e servizi MCP. Quando aggiungi un server con ambito del progetto, Claude Code crea o aggiorna automaticamente questo file con la struttura di configurazione appropriata.

470 474

471```bash theme={null}475```bash theme={null}

472# Aggiungi un server con ambio del progetto476# Aggiungi un server con ambito del progetto

473claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp477claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp

474```478```

475 479

944 </Step>948 </Step>

945</Steps>949</Steps>

946 950

951Un server che hai aggiunto in Claude Code ha [precedenza](#scope-hierarchy-and-precedence) rispetto a un connettore claude.ai che punta allo stesso URL. Quando ciò accade, `/mcp` elenca il connettore come nascosto e mostra come rimuovere il duplicato se preferisci utilizzare il connettore.

952

947Per disabilitare i server MCP di claude.ai in Claude Code, imposta la variabile di ambiente `ENABLE_CLAUDEAI_MCP_SERVERS` su `false`:953Per disabilitare i server MCP di claude.ai in Claude Code, imposta la variabile di ambiente `ENABLE_CLAUDEAI_MCP_SERVERS` su `false`:

948 954

949```bash theme={null}955```bash theme={null}

1183 1189

1184Il campo `alwaysLoad` è disponibile su tutti i tipi di server e richiede Claude Code v2.1.121 o successivo. Un server MCP può anche contrassegnare singoli strumenti come sempre caricati includendo `"anthropic/alwaysLoad": true` nell'oggetto `_meta` dello strumento, che ha lo stesso effetto solo per quello strumento.1190Il campo `alwaysLoad` è disponibile su tutti i tipi di server e richiede Claude Code v2.1.121 o successivo. Un server MCP può anche contrassegnare singoli strumenti come sempre caricati includendo `"anthropic/alwaysLoad": true` nell'oggetto `_meta` dello strumento, che ha lo stesso effetto solo per quello strumento.

1185 1191

1192L'impostazione di `alwaysLoad: true` blocca anche l'avvio fino a quando il server non si connette, limitato al timeout di connessione standard di 5 secondi. Questo si applica anche quando [`MCP_CONNECTION_NONBLOCKING=1`](/it/env-vars) è impostato, poiché gli strumenti devono essere presenti quando viene costruito il primo prompt. Gli altri server si connettono ancora in background quando il nonblocking è abilitato.

1193

1186## Utilizza i prompt MCP come comandi1194## Utilizza i prompt MCP come comandi

1187 1195

1188I server MCP possono esporre prompt che diventano disponibili come comandi in Claude Code.1196I server MCP possono esporre prompt che diventano disponibili come comandi in Claude Code.

1351* `https://*.example.com/*` - Consenti qualsiasi sottodominio di example.com1359* `https://*.example.com/*` - Consenti qualsiasi sottodominio di example.com

1352* `http://localhost:*/*` - Consenti qualsiasi porta su localhost1360* `http://localhost:*/*` - Consenti qualsiasi porta su localhost

1353 1361

1362La corrispondenza del nome host è insensibile alle maiuscole/minuscole e ignora un punto FQDN finale, corrispondendo alla semantica DNS. Un pattern come `*://Mcp.Example.com/*` corrisponde a `https://mcp.example.com/api`, e `https://mcp.example.com.` è trattato come `https://mcp.example.com`. Gli schemi e i percorsi rimangono sensibili alle maiuscole/minuscole.

1363

1354**Comportamento del server remoto**:1364**Comportamento del server remoto**:

1355 1365

1356* Quando l'allowlist contiene **qualsiasi** voce `serverUrl`, i server remoti **devono** corrispondere a uno di quei pattern URL1366* Quando l'allowlist contiene **qualsiasi** voce `serverUrl`, i server remoti **devono** corrispondere a uno di quei pattern URL

memory.md +2 −0

Details

378* Rendi le istruzioni più specifiche. "Usa indentazione a 2 spazi" funziona meglio di "formatta il codice bene".378* Rendi le istruzioni più specifiche. "Usa indentazione a 2 spazi" funziona meglio di "formatta il codice bene".

379* Cerca istruzioni conflittuali tra i file CLAUDE.md. Se due file danno una guida diversa per lo stesso comportamento, Claude potrebbe sceglierne una arbitrariamente.379* Cerca istruzioni conflittuali tra i file CLAUDE.md. Se due file danno una guida diversa per lo stesso comportamento, Claude potrebbe sceglierne una arbitrariamente.

380 380

381Se l'istruzione è qualcosa che deve essere eseguito in un punto specifico, come prima di ogni commit o dopo ogni modifica di file, scrivila come un [hook](/it/hooks-guide). Gli hook vengono eseguiti come comandi shell in eventi del ciclo di vita fissi e si applicano indipendentemente da ciò che Claude decide di fare.

382

381Per le istruzioni che vuoi a livello di prompt di sistema, usa [`--append-system-prompt`](/it/cli-reference#system-prompt-flags). Questo deve essere passato ad ogni invocazione, quindi è più adatto a script e automazione che all'uso interattivo.383Per le istruzioni che vuoi a livello di prompt di sistema, usa [`--append-system-prompt`](/it/cli-reference#system-prompt-flags). Questo deve essere passato ad ogni invocazione, quindi è più adatto a script e automazione che all'uso interattivo.

382 384

383<Tip>385<Tip>

model-config.md +20 −6

Details

184 184

185La scala dello sforzo è calibrata per modello, quindi lo stesso nome di livello non rappresenta lo stesso valore sottostante tra i modelli.185La scala dello sforzo è calibrata per modello, quindi lo stesso nome di livello non rappresenta lo stesso valore sottostante tra i modelli.

186 186

187Per un ragionamento profondo una tantum senza modificare l'impostazione della sessione, includere "ultrathink" nel prompt. Questo aggiunge un'istruzione in contesto che dice al modello di ragionare di più su quel turno; non cambia il livello di sforzo inviato all'API.187#### Utilizzare ultrathink per il ragionamento profondo una tantum

188

189Includi `ultrathink` in qualsiasi punto del prompt per richiedere un ragionamento più profondo su quel turno senza modificare l'impostazione dello sforzo della sessione. Claude Code riconosce la parola chiave e aggiunge un'istruzione in contesto. Il livello di sforzo inviato all'API rimane invariato. Altre frasi come "think", "think hard" e "think more" vengono passate come testo ordinario del prompt e non vengono riconosciute come parole chiave.

188 190

189#### Impostare il livello di sforzo191#### Impostare il livello di sforzo

190 192

209 211

210Su Opus 4.6 e Sonnet 4.6, è possibile impostare `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` per ripristinare il budget di pensiero fisso precedente controllato da `MAX_THINKING_TOKENS`. Vedere [variabili di ambiente](/it/env-vars).212Su Opus 4.6 e Sonnet 4.6, è possibile impostare `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` per ripristinare il budget di pensiero fisso precedente controllato da `MAX_THINKING_TOKENS`. Vedere [variabili di ambiente](/it/env-vars).

211 213

214### Pensiero esteso

215

216Il pensiero esteso è il ragionamento che Claude emette prima di rispondere. Sui modelli che supportano il [ragionamento adattivo](#adjust-effort-level), il livello di sforzo è il controllo principale per la quantità di pensiero che si verifica; le impostazioni seguenti attivano o disattivano il pensiero e controllano come viene visualizzato.

217

218| Controllo | Come impostarlo |

219| :------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

220| Attiva/disattiva per la sessione corrente | Premere `Option+T` su macOS o `Alt+T` su Windows e Linux |

221| Impostare il valore predefinito globale | Eseguire `/config` e attivare/disattivare la modalità di pensiero. Salvato come `alwaysThinkingEnabled` in `~/.claude/settings.json` |

222| Disabilitare indipendentemente dallo sforzo | Impostare [`MAX_THINKING_TOKENS=0`](/it/env-vars). Altri valori si applicano solo con un [budget di pensiero fisso](#adaptive-reasoning-and-fixed-thinking-budgets) |

223

224L'output del pensiero è compresso per impostazione predefinita. Premere `Ctrl+O` per attivare/disattivare la modalità dettagliata e visualizzare il ragionamento come testo grigio in corsivo. Le sessioni interattive sull'API Anthropic ricevono blocchi di pensiero redatti per impostazione predefinita, quindi impostare `showThinkingSummaries: true` nelle [impostazioni](/it/settings) se desideri che i riepiloghi completi siano disponibili quando li espandi. Viene addebitato il costo di tutti i token di pensiero generati, anche quando compressi o redatti.

225

212### Contesto esteso226### Contesto esteso

213 227

214Opus 4.7, Opus 4.6 e Sonnet 4.6 supportano una [finestra di contesto di 1 milione di token](https://platform.claude.com/docs/it/build-with-claude/context-windows#1m-token-context-window) per sessioni lunghe con basi di codice di grandi dimensioni.228Opus 4.7, Opus 4.6 e Sonnet 4.6 supportano una [finestra di contesto di 1 milione di token](https://platform.claude.com/docs/it/build-with-claude/context-windows#1m-token-context-window) per sessioni lunghe con basi di codice di grandi dimensioni.

247 261

248## Aggiungere un'opzione di modello personalizzato262## Aggiungere un'opzione di modello personalizzato

249 263

250Utilizzare `ANTHROPIC_CUSTOM_MODEL_OPTION` per aggiungere una singola voce personalizzata al selettore `/model` senza sostituire gli alias incorporati. Questo è utile per testare ID di modello che Claude Code non elenca per impostazione predefinita. Per le distribuzioni di gateway LLM, Claude Code popola il selettore automaticamente dall'endpoint `/v1/models` del gateway, quindi questa variabile è necessaria solo quando la scoperta non restituisce il modello desiderato. Vedere [Selezione del modello del gateway LLM](/it/llm-gateway#model-selection).264Utilizzare `ANTHROPIC_CUSTOM_MODEL_OPTION` per aggiungere una singola voce personalizzata al selettore `/model` senza sostituire gli alias incorporati. Questo è utile per testare ID di modello che Claude Code non elenca per impostazione predefinita. Per le distribuzioni di gateway LLM, Claude Code può popolare il selettore dall'endpoint `/v1/models` del gateway quando `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1` è impostato, quindi questa variabile è necessaria solo quando la scoperta è disabilitata o non restituisce il modello desiderato. Vedere [Selezione del modello del gateway LLM](/it/llm-gateway#model-selection).

251 265

252Questo esempio imposta tutte e tre le variabili per rendere selezionabile una distribuzione Opus instradata tramite gateway:266Questo esempio imposta tutte e tre le variabili per rendere selezionabile una distribuzione Opus instradata tramite gateway:

253 267

266È possibile utilizzare le seguenti variabili di ambiente, che devono essere **nomi di modelli** completi (o equivalenti per il provider API), per controllare i nomi dei modelli a cui gli alias si mappano.280È possibile utilizzare le seguenti variabili di ambiente, che devono essere **nomi di modelli** completi (o equivalenti per il provider API), per controllare i nomi dei modelli a cui gli alias si mappano.

267 281

268| Variabile di ambiente | Descrizione |282| Variabile di ambiente | Descrizione |

269| -------------------------------- | ---------------------------------------------------------------------------------------------------------- |283| -------------------------------- | ------------------------------------------------------------------------------------------------------ |

271| `ANTHROPIC_DEFAULT_SONNET_MODEL` | Il modello da utilizzare per `sonnet`, o per `opusplan` quando Plan Mode non è attivo. |285| `ANTHROPIC_DEFAULT_SONNET_MODEL` | Il modello da utilizzare per `sonnet`, o per `opusplan` quando Plan Mode non è attivo. |

272| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | Il modello da utilizzare per `haiku`, o per [funzionalità in background](/it/costs#background-token-usage) |286| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | Il modello da utilizzare per `haiku`, o [funzionalità in background](/it/costs#background-token-usage) |

274 288

275Nota: `ANTHROPIC_SMALL_FAST_MODEL` è deprecato a favore di `ANTHROPIC_DEFAULT_HAIKU_MODEL`.289Nota: `ANTHROPIC_SMALL_FAST_MODEL` è deprecato a favore di `ANTHROPIC_DEFAULT_HAIKU_MODEL`.

320 334

321Gli stessi suffissi `_NAME`, `_DESCRIPTION` e `_SUPPORTED_CAPABILITIES` sono disponibili per `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL` e `ANTHROPIC_CUSTOM_MODEL_OPTION`.335Gli stessi suffissi `_NAME`, `_DESCRIPTION` e `_SUPPORTED_CAPABILITIES` sono disponibili per `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL` e `ANTHROPIC_CUSTOM_MODEL_OPTION`.

322 336

323Claude Code abilita funzionalità come [livelli di sforzo](#adjust-effort-level) e [extended thinking](/it/common-workflows#use-extended-thinking-thinking-mode) abbinando l'ID del modello rispetto a modelli noti. Gli ID specifici del provider come ARN Bedrock o nomi di distribuzione personalizzati spesso non corrispondono a questi modelli, lasciando le funzionalità supportate disabilitate. Impostare `_SUPPORTED_CAPABILITIES` per dire a Claude Code quali funzionalità il modello effettivamente supporta:337Claude Code abilita funzionalità come [livelli di sforzo](#adjust-effort-level) e [extended thinking](#extended-thinking) abbinando l'ID del modello rispetto a modelli noti. Gli ID specifici del provider come ARN Bedrock o nomi di distribuzione personalizzati spesso non corrispondono a questi modelli, lasciando le funzionalità supportate disabilitate. Impostare `_SUPPORTED_CAPABILITIES` per dire a Claude Code quali funzionalità il modello effettivamente supporta:

324 338

325| Valore di capacità | Abilita |339| Valore di capacità | Abilita |

326| ---------------------- | ------------------------------------------------------------------------------------------------- |340| ---------------------- | ------------------------------------------------------------------------------------------------- |

328| `xhigh_effort` | {/* min-version: 2.1.111 */}Il livello di sforzo `xhigh` |342| `xhigh_effort` | {/* min-version: 2.1.111 */}Il livello di sforzo `xhigh` |

331| `adaptive_thinking` | Ragionamento adattivo che alloca dinamicamente il pensiero in base alla complessità dell'attività |345| `adaptive_thinking` | Ragionamento adattivo che alloca dinamicamente il pensiero in base alla complessità dell'attività |

333 347

monitoring-usage.md +77 −5

Details

64 Le impostazioni gestite possono essere distribuite tramite MDM (Mobile Device Management) o altre soluzioni di gestione dei dispositivi. Le variabili di ambiente definite nel file di impostazioni gestite hanno una precedenza elevata e non possono essere sovrascritte dagli utenti.64 Le impostazioni gestite possono essere distribuite tramite MDM (Mobile Device Management) o altre soluzioni di gestione dei dispositivi. Le variabili di ambiente definite nel file di impostazioni gestite hanno una precedenza elevata e non possono essere sovrascritte dagli utenti.

65</Note>65</Note>

66 66

67Claude Code non passa le variabili di ambiente `OTEL_*` ai sottoprocessi che genera, incluso lo strumento Bash, gli hooks, i server MCP e i language server. Un'applicazione strumentata con OpenTelemetry che esegui tramite lo strumento Bash non eredita l'endpoint dell'esportatore di Claude Code o le intestazioni, quindi imposta quelle variabili direttamente nel comando se quell'applicazione ha bisogno di esportare la propria telemetria.

67## Dettagli della configurazione69## Dettagli della configurazione

68 70

69### Variabili di configurazione comuni71### Variabili di configurazione comuni

83| `OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY` | Chiave client per l'autenticazione mTLS | Percorso del file della chiave client |

84| `OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE` | Certificato client per l'autenticazione mTLS | Percorso del file del certificato client |

85| `OTEL_METRIC_EXPORT_INTERVAL` | Intervallo di esportazione in millisecondi (predefinito: 60000) | `5000`, `60000` |85| `OTEL_METRIC_EXPORT_INTERVAL` | Intervallo di esportazione in millisecondi (predefinito: 60000) | `5000`, `60000` |

86| `OTEL_LOGS_EXPORT_INTERVAL` | Intervallo di esportazione dei log in millisecondi (predefinito: 5000) | `1000`, `10000` |86| `OTEL_LOGS_EXPORT_INTERVAL` | Intervallo di esportazione dei log in millisecondi (predefinito: 5000) | `1000`, `10000` |

91| `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` | Preferenza di temporalità delle metriche (predefinito: `delta`). Imposta su `cumulative` se il tuo backend prevede temporalità cumulativa | `delta`, `cumulative` |91| `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` | Preferenza di temporalità delle metriche (predefinito: `delta`). Imposta su `cumulative` se il tuo backend prevede temporalità cumulativa | `delta`, `cumulative` |

92| `CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS` | Intervallo per l'aggiornamento delle intestazioni dinamiche (predefinito: 1740000ms / 29 minuti) | `900000` |92| `CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS` | Intervallo per l'aggiornamento delle intestazioni dinamiche (predefinito: 1740000ms / 29 minuti) | `900000` |

93 93

94### Autenticazione mTLS

96Il modo in cui configuri i certificati client per l'esportatore OTLP dipende dal protocollo OTLP in uso per quel segnale, impostato tramite `OTEL_EXPORTER_OTLP_PROTOCOL` o l'override per segnale. La stessa configurazione si applica a metriche, log e tracce.

98| Protocollo | Variabili di certificato client | Fidati del CA del collettore con |

99| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------- |

100| `http/protobuf`, `http/json` | `CLAUDE_CODE_CLIENT_CERT`, `CLAUDE_CODE_CLIENT_KEY`, e facoltativamente `CLAUDE_CODE_CLIENT_KEY_PASSPHRASE`. Vedi [Configurazione di rete](/it/network-config#mtls-authentication) | `NODE_EXTRA_CA_CERTS` |

101| `grpc` | `OTEL_EXPORTER_OTLP_CLIENT_KEY` e `OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE`, o le varianti per segnale come `OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY` per usare un certificato diverso per segnale | `OTEL_EXPORTER_OTLP_CERTIFICATE` |

102

103Per `grpc`, l'SDK OpenTelemetry legge direttamente le variabili OTLP standard, quindi le configurazioni esistenti che impostano le variabili di metriche per segnale continuano a funzionare.

104

94### Controllo della cardinalità delle metriche105### Controllo della cardinalità delle metriche

95 106

96Le seguenti variabili di ambiente controllano quali attributi sono inclusi nelle metriche per gestire la cardinalità:107Le seguenti variabili di ambiente controllano quali attributi sono inclusi nelle metriche per gestire la cardinalità:

107 118

108Le tracce distribuite esportano span che collegano ogni prompt dell'utente alle richieste API e alle esecuzioni degli strumenti che attiva, in modo da poter visualizzare una richiesta completa come una singola traccia nel tuo backend di traccia.119Le tracce distribuite esportano span che collegano ogni prompt dell'utente alle richieste API e alle esecuzioni degli strumenti che attiva, in modo da poter visualizzare una richiesta completa come una singola traccia nel tuo backend di traccia.

109 120

110Le tracce sono disabilitate per impostazione predefinita. Per abilitarle, imposta sia `CLAUDE_CODE_ENABLE_TELEMETRY=1` che `CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1`, quindi imposta `OTEL_TRACES_EXPORTER` per scegliere dove vengono inviati gli span. Le tracce riutilizzano la [configurazione OTLP comune](#common-configuration-variables) per endpoint, protocollo e intestazioni.121Le tracce sono disabilitate per impostazione predefinita. Per abilitarle, imposta sia `CLAUDE_CODE_ENABLE_TELEMETRY=1` che `CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1`, quindi imposta `OTEL_TRACES_EXPORTER` per scegliere dove vengono inviati gli span. Le tracce riutilizzano la [configurazione OTLP comune](#common-configuration-variables) per endpoint, protocollo, intestazioni e [mTLS](#mtls-authentication).

111 122

113| ------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------ |124| ------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------ |

233 244

234### Intestazioni dinamiche245### Intestazioni dinamiche

235 246

236Per gli ambienti aziendali che richiedono autenticazione dinamica, puoi configurare uno script per generare intestazioni dinamicamente:247Per gli ambienti aziendali che richiedono autenticazione dinamica, puoi configurare uno script per generare intestazioni dinamicamente. Le intestazioni dinamiche si applicano solo ai protocolli `http/protobuf` e `http/json`. L'esportatore `grpc` utilizza solo il valore statico `OTEL_EXPORTER_OTLP_HEADERS`.

237 248

238#### Configurazione delle impostazioni249#### Configurazione delle impostazioni

239 250

410 421

411#### Contatore di pull request422#### Contatore di pull request

412 423

413Incrementato quando si creano pull request tramite Claude Code.424Incrementato quando Claude Code crea una pull request o merge request tramite un comando shell o uno strumento MCP.

414 425

415**Attributi**:426**Attributi**:

416 427

899 910

900**Monitoraggio delle prestazioni**: traccia le durate delle richieste API e i tempi di esecuzione dello strumento per identificare i colli di bottiglia delle prestazioni.911**Monitoraggio delle prestazioni**: traccia le durate delle richieste API e i tempi di esecuzione dello strumento per identificare i colli di bottiglia delle prestazioni.

901 912

913## Audit degli eventi di sicurezza

914

915Gli eventi OpenTelemetry sono la fonte di dati di audit per l'attività di Claude Code. Ogni evento porta attributi di identità che collegano le chiamate agli strumenti, l'attività MCP e le decisioni di autorizzazione all'utente che le ha attivate, e l'esportatore di log OTLP può fornire questi eventi a qualsiasi piattaforma SIEM (Security Information and Event Management) con un ricevitore OTLP o a un OpenTelemetry Collector che inoltra al tuo SIEM.

916

917### Attribuisci le azioni agli utenti

918

919Gli [attributi standard](#standard-attributes) su ogni evento includono l'identità dell'utente autenticato: `user.email`, `user.account_uuid`, `user.account_id`, e `organization.id` quando accedi con un account Claude, più l'`user.id` con ambito di installazione e il `session.id` per sessione.

920

921Le chiamate agli strumenti MCP, i comandi Bash e le modifiche ai file sono quindi attribuite allo sviluppatore che ha avviato la sessione. Claude Code non agisce con un account di servizio separato; l'identità registrata su ogni evento è l'account Claude dello sviluppatore.

922

923Quando Claude Code si autentica con una chiave API diretta, o contro Bedrock, Vertex AI, o Microsoft Foundry, non c'è un account Claude nella sessione e solo `user.id` e `session.id` vengono popolati. In questi deployment, allega l'identità dell'utente tu stesso con `OTEL_RESOURCE_ATTRIBUTES`, impostato per utente tramite il file [impostazioni gestite](#administrator-configuration) o un wrapper di avvio:

924

925```bash theme={null}

926export OTEL_RESOURCE_ATTRIBUTES="enduser.id=jdoe@example.com,enduser.directory_id=S-1-5-21-..."

927```

928

929### Audit dell'attività MCP

930

931Per acquisire l'attività del server MCP con dettagli completi della chiamata, abilita l'esportatore di log e imposta `OTEL_LOG_TOOL_DETAILS=1`. Ogni operazione MCP produce quindi eventi strutturati che portano il nome del server, il nome dello strumento e gli argomenti della chiamata insieme agli attributi di identità standard:

932

933| Evento | Cosa registra per MCP |

934| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

935| `mcp_server_connection` | Connessione del server, disconnessione e guasto di connessione con `server_name`, `transport_type`, `server_scope`, e dettagli dell'errore |

936| `tool_result` | Ogni chiamata dello strumento MCP con `tool_name` e `mcp_server_scope`, un payload `tool_parameters` contenente `mcp_server_name` e `mcp_tool_name`, e un payload `tool_input` contenente gli argomenti della chiamata |

937| `tool_decision` | Se la chiamata è stata consentita o negata, e se la decisione proveniva da config, un hook, o l'utente |

938

939Senza `OTEL_LOG_TOOL_DETAILS`, gli eventi `tool_result` portano comunque `tool_name` e `mcp_server_scope` ma omettono la suddivisione `mcp_server_name`/`mcp_tool_name` e gli argomenti, e gli eventi `mcp_server_connection` omettono `server_name` e il messaggio di errore.

940

941### Mappa le domande di sicurezza agli eventi

942

943Quando costruisci regole di rilevamento, cerca il segnale che vuoi monitorare e interroga il tuo backend per l'evento corrispondente e gli attributi:

944

945| Segnale | Evento | Attributi chiave |

946| ------------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------ |

947| Chiamata dello strumento consentita o negata, e da cosa | `tool_decision` | `decision`, `source`, `tool_name` |

948| Escalation della modalità di autorizzazione | `permission_mode_changed` | `from_mode`, `to_mode`, `trigger` |

949| Hook della politica ha bloccato un'azione | `hook_execution_complete` | `hook_event`, `num_blocking` |

950| Login, logout e guasto di autenticazione | `auth` | `action`, `success`, `error_category` |

951| Connessione del server MCP o guasto | `mcp_server_connection` | `status`, `server_name`, `error_code` |

952| Plugin installato e la sua fonte | `plugin_installed` | `plugin.name`, `marketplace.name`, `marketplace.is_official` |

953| Comandi eseguiti e file toccati | `tool_result` con `OTEL_LOG_TOOL_DETAILS=1` | `tool_parameters`, `tool_input` |

954

955Claude Code emette solo il flusso di eventi grezzo. Il rilevamento delle anomalie, il baselining, la correlazione tra sessioni e gli avvisi sono responsabilità del tuo SIEM o backend di osservabilità.

956

957### Invia gli eventi a un SIEM

958

959Punta `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` al ricevitore OTLP del tuo SIEM, o a un OpenTelemetry Collector che inoltra all'API di ingestione nativa del tuo SIEM. Il seguente esempio di impostazioni gestite esporta solo gli eventi, con dettagli completi dello strumento abilitati per il controllo MCP e Bash:

960

961```json theme={null}

962{

963 "env": {

964 "CLAUDE_CODE_ENABLE_TELEMETRY": "1",

965 "OTEL_LOGS_EXPORTER": "otlp",

966 "OTEL_LOG_TOOL_DETAILS": "1",

967 "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL": "http/protobuf",

968 "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": "https://siem.example.com:4318/v1/logs",

969 "OTEL_EXPORTER_OTLP_HEADERS": "Authorization=Bearer your-siem-token"

970 }

971}

972```

973

902## Considerazioni sul backend974## Considerazioni sul backend

903 975

904La scelta dei backend di metriche, log e tracce determina i tipi di analisi che puoi eseguire:976La scelta dei backend di metriche, log e tracce determina i tipi di analisi che puoi eseguire:

output-styles.md +26 −48

Details

6 6

7> Adattare Claude Code per usi oltre l'ingegneria del software7> Adattare Claude Code per usi oltre l'ingegneria del software

8 8

~~9Output styles consente di utilizzare Claude Code come qualsiasi tipo di agente mantenendo~~9Output styles cambiano il modo in cui Claude risponde, non quello che Claude sa. Modificano il prompt di sistema per impostare il ruolo, il tono e il formato di output mantenendo le capacità principali come l'esecuzione di script, la lettura e la scrittura di file e il tracciamento dei TODO. Utilizzatene uno quando continuate a ripetere la stessa voce o formato ad ogni turno, oppure quando desiderate che Claude agisca come qualcosa di diverso da un ingegnere del software.

~~10le sue capacità principali, come l'esecuzione di script locali, la lettura/scrittura di file e~~10

~~11il tracciamento dei TODO.~~11Per le istruzioni relative al vostro progetto, alle convenzioni o al codebase, utilizzate [CLAUDE.md](/it/memory) invece.

12 12

13## Output styles integrati13## Output styles integrati

14 14

~~15Lo **Default** output style di Claude Code è il prompt di sistema esistente, progettato~~15Lo **Default** output style di Claude Code è il prompt di sistema esistente, progettato per aiutarvi a completare i compiti di ingegneria del software in modo efficiente.

~~16per aiutarvi a completare i compiti di ingegneria del software in modo efficiente.~~

17 16

~~18Ci sono due output styles integrati aggiuntivi focalizzati sull'insegnamento del~~17Ci sono due output styles integrati aggiuntivi focalizzati sull'insegnamento del codebase e su come Claude opera:

~~19codebase e su come Claude opera:~~

20 18

~~21* **Explanatory**: Fornisce "Insights" educativi tra l'aiuto nel completamento dei compiti~~19* **Explanatory**: Fornisce "Insights" educativi tra l'aiuto nel completamento dei compiti di ingegneria del software. Aiuta a comprendere le scelte di implementazione e i pattern del codebase.

~~22 di ingegneria del software. Aiuta a comprendere le scelte di implementazione~~

~~23 e i pattern del codebase.~~

24 20

~~25* **Learning**: Modalità collaborativa di apprendimento pratico in cui Claude non solo~~21* **Learning**: Modalità collaborativa di apprendimento pratico in cui Claude non solo condividerà "Insights" durante la codifica, ma vi chiederà anche di contribuire con piccoli, strategici pezzi di codice voi stessi. Claude Code aggiungerà marcatori `TODO(human)` nel vostro codice per voi da implementare.

~~26 condividerà "Insights" durante la codifica, ma vi chiederà anche di contribuire con piccoli,~~

~~27 strategici pezzi di codice voi stessi. Claude Code aggiungerà marcatori `TODO(human)` nel vostro~~

~~28 codice per voi da implementare.~~

29 22

30## Come funzionano gli output styles23## Come funzionano gli output styles

31 24

32Gli output styles modificano direttamente il prompt di sistema di Claude Code.25Gli output styles modificano direttamente il prompt di sistema di Claude Code.

33 26

~~34* Gli output styles personalizzati escludono istruzioni per la codifica (come la verifica del codice~~27* Gli output styles personalizzati escludono istruzioni per la codifica (come la verifica del codice con i test), a meno che `keep-coding-instructions` non sia true.

~~35 con i test), a meno che `keep-coding-instructions` non sia true.~~28* Tutti gli output styles hanno le loro istruzioni personalizzate aggiunte alla fine del prompt di sistema.

~~36* Tutti gli output styles hanno le loro istruzioni personalizzate aggiunte alla fine del~~29* Tutti gli output styles attivano promemoria affinché Claude aderisca alle istruzioni dell'output style durante la conversazione.

~~37 prompt di sistema.~~

~~38* Tutti gli output styles attivano promemoria affinché Claude aderisca alle istruzioni~~

~~39 dell'output style durante la conversazione.~~

40 30

~~41L'utilizzo dei token dipende dallo stile. L'aggiunta di istruzioni al prompt di sistema~~31L'utilizzo dei token dipende dallo stile. L'aggiunta di istruzioni al prompt di sistema aumenta i token di input, anche se il prompt caching riduce questo costo dopo la prima richiesta in una sessione. Gli output styles integrati Explanatory e Learning producono risposte più lunghe rispetto a Default per progettazione, il che aumenta i token di output. Per gli stili personalizzati, l'utilizzo dei token di output dipende da ciò che le vostre istruzioni dicono a Claude di produrre.

~~42aumenta i token di input, anche se il prompt caching riduce questo costo dopo la prima~~

~~43richiesta in una sessione. Gli output styles integrati Explanatory e Learning producono~~

~~44risposte più lunghe rispetto a Default per progettazione, il che aumenta i token di output. Per~~

~~45gli stili personalizzati, l'utilizzo dei token di output dipende da ciò che le vostre istruzioni dicono a Claude~~

~~46di produrre.~~

47 32

48## Cambiare il vostro output style33## Cambiare il vostro output style

49 34

~~50Eseguite `/config` e selezionate **Output style** per scegliere uno stile da un menu. La vostra~~35Eseguite `/config` e selezionate **Output style** per scegliere uno stile da un menu. La vostra selezione viene salvata in `.claude/settings.local.json` al [livello del progetto locale](/it/settings).

~~51selezione viene salvata in `.claude/settings.local.json` al~~

~~52[livello del progetto locale](/it/settings).~~

53 36

~~54Per impostare uno stile senza il menu, modificate direttamente il campo `outputStyle` in un~~37Per impostare uno stile senza il menu, modificate direttamente il campo `outputStyle` in un file di impostazioni:

~~55file di impostazioni:~~

56 38

57```json theme={null}39```json theme={null}

58{40{

60}42}

61```43```

62 44

~~63Poiché l'output style è impostato nel prompt di sistema all'avvio della sessione,~~45Poiché l'output style è impostato nel prompt di sistema all'avvio della sessione, le modifiche hanno effetto la prossima volta che avviate una nuova sessione. Questo mantiene il prompt di sistema stabile durante una conversazione in modo che il prompt caching possa ridurre la latenza e il costo.

~~64le modifiche hanno effetto la prossima volta che avviate una nuova sessione. Questo mantiene il prompt di sistema~~

~~65stabile durante una conversazione in modo che il prompt caching possa ridurre la latenza e~~

~~66il costo.~~

67 46

68## Creare un output style personalizzato47## Creare un output style personalizzato

69 48

~~70Gli output styles personalizzati sono file Markdown con frontmatter e il testo che verrà~~49Gli output styles personalizzati sono file Markdown con frontmatter e il testo che verrà aggiunto al prompt di sistema:

~~71aggiunto al prompt di sistema:~~

72 50

73```markdown theme={null}51```markdown theme={null}

74---52---

87[Define how the assistant should behave in this style...]65[Define how the assistant should behave in this style...]

88```66```

89 67

~~90Potete salvare questi file a livello utente (`~/.claude/output-styles`) o~~68Potete salvare questi file a tre livelli:

~~91a livello di progetto (`.claude/output-styles`).~~69

70* Utente: `~/.claude/output-styles`

71* Progetto: `.claude/output-styles`

72* Politica gestita: `.claude/output-styles` all'interno della [directory delle impostazioni gestite](/it/settings#settings-files)

74I [Plugins](/it/plugins-reference) possono anche fornire output styles in una directory `output-styles/`.

92 75

93### Frontmatter76### Frontmatter

94 77

95I file di output style supportano frontmatter per specificare i metadati:78I file di output style supportano frontmatter per specificare i metadati:

96 79

~~98| :------------------------- | :--------------------------------------------------------------------------------- | :------------------------ |~~81| :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------ |

85| `force-for-plugin` | Solo output styles dei plugin: applica questo stile automaticamente ogni volta che il plugin è abilitato, senza richiedere agli utenti di selezionarlo. Sostituisce l'impostazione `outputStyle` dell'utente. Se più plugin abilitati impostano questo, il primo caricato vince. | false |

102 86

103## Confronti con funzionalità correlate87## Confronti con funzionalità correlate

104 88

105### Output Styles vs. CLAUDE.md vs. --append-system-prompt89### Output Styles vs. CLAUDE.md vs. --append-system-prompt

106 90

107Gli output styles "disattivano" completamente le parti del prompt di sistema predefinito di Claude Code91Gli output styles "disattivano" completamente le parti del prompt di sistema predefinito di Claude Code specifiche per l'ingegneria del software. Né CLAUDE.md né `--append-system-prompt` modificano il prompt di sistema predefinito di Claude Code. CLAUDE.md aggiunge i contenuti come messaggio utente *seguendo* il prompt di sistema predefinito di Claude Code. `--append-system-prompt` aggiunge il contenuto al prompt di sistema.

108specifiche per l'ingegneria del software. Né CLAUDE.md né

109`--append-system-prompt` modificano il prompt di sistema predefinito di Claude Code. CLAUDE.md

110aggiunge i contenuti come messaggio utente *seguendo* il prompt di sistema predefinito di Claude Code. `--append-system-prompt` aggiunge il contenuto al prompt di sistema.

111 92

112### Output Styles vs. [Agents](/it/sub-agents)93### Output Styles vs. [Agents](/it/sub-agents)

113 94

114Gli output styles influenzano direttamente il loop dell'agente principale e influenzano solo il prompt95Gli output styles influenzano direttamente il loop dell'agente principale e influenzano solo il prompt di sistema. Gli agenti vengono invocati per gestire compiti specifici e possono includere impostazioni aggiuntive come il modello da utilizzare, gli strumenti disponibili e un contesto su quando utilizzare l'agente.

115di sistema. Gli agenti vengono invocati per gestire compiti specifici e possono includere impostazioni aggiuntive

116come il modello da utilizzare, gli strumenti disponibili e un contesto

117su quando utilizzare l'agente.

118 96

119### Output Styles vs. [Skills](/it/skills)97### Output Styles vs. [Skills](/it/skills)

120 98

plugins.md +6 −0

Details

315 ```315 ```

316</Tip>316</Tip>

317 317

318Per testare un plugin che è già stato confezionato come archivio `.zip` e ospitato su un URL, come un artefatto di build CI, usa `--plugin-url` invece. Claude Code recupera l'archivio all'avvio e lo carica solo per quella sessione. Se il recupero fallisce o l'archivio non è valido, Claude Code segnala un errore di caricamento del plugin e si avvia senza di esso. Le stesse [considerazioni sulla fiducia](/it/discover-plugins#security) si applicano come per qualsiasi fonte di plugin: punta questo flag solo ad archivi che controlli o di cui ti fidi.

319

320```bash theme={null}

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

322```

323

318### Esegui il debug dei problemi del plugin324### Esegui il debug dei problemi del plugin

319 325

320Se il tuo plugin non funziona come previsto:326Se il tuo plugin non funziona come previsto:

plugins-reference.md +16 −10

Details

301]301]

302```302```

303 303

304Per dichiarare monitor inline, imposta la chiave `monitors` in `plugin.json` sullo stesso array. Per caricare da un percorso non predefinito, imposta `monitors` su una stringa di percorso relativo come `"./config/monitors.json"`.304Per dichiarare monitor inline, imposta `experimental.monitors` in `plugin.json` sullo stesso array. Per caricare da un percorso non predefinito, imposta `experimental.monitors` su una stringa di percorso relativo come `"./config/monitors.json"`. I monitor sono un [componente sperimentale](#experimental-components).

305 305

306**Campi obbligatori:**306**Campi obbligatori:**

307 307

323 323

324### Themes324### Themes

325 325

326I plugin possono fornire temi di colore che appaiono in `/theme` insieme ai preset integrati e ai temi locali dell'utente. Un tema è un file JSON in `themes/` con un preset `base` e una mappa sparsa `overrides` di token di colore.326I plugin possono fornire temi di colore che appaiono in `/theme` insieme ai preset integrati e ai temi locali dell'utente. Un tema è un file JSON in `themes/` con un preset `base` e una mappa sparsa `overrides` di token di colore. I temi sono un [componente sperimentale](#experimental-components).

327 327

328```json theme={null}328```json theme={null}

329{329{

384 "hooks": "./config/hooks.json",384 "hooks": "./config/hooks.json",

385 "mcpServers": "./mcp-config.json",385 "mcpServers": "./mcp-config.json",

386 "outputStyles": "./styles/",386 "outputStyles": "./styles/",

387 "themes": "./themes/",

388 "lspServers": "./.lsp.json",387 "lspServers": "./.lsp.json",

389 "monitors": "./monitors.json",388 "experimental": {

389 "themes": "./themes/",

390 "monitors": "./monitors.json"

391 },

390 "dependencies": [392 "dependencies": [

391 "helper-lib",393 "helper-lib",

392 { "name": "secrets-vault", "version": "~2.1.0" }394 { "name": "secrets-vault", "version": "~2.1.0" }

420### Campi del percorso del componente422### Campi del percorso del componente

421 423

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

435| `dependencies` | array | Altri plugin richiesti da questo plugin, facoltativamente con vincoli di versione semver. Vedi [Vincola le versioni delle dipendenze del plugin](/it/plugin-dependencies) | `[{ "name": "secrets-vault", "version": "~2.1.0" }]` |437| `dependencies` | array | Altri plugin richiesti da questo plugin, facoltativamente con vincoli di versione semver. Vedi [Vincola le versioni delle dipendenze del plugin](/it/plugin-dependencies) | `[{ "name": "secrets-vault", "version": "~2.1.0" }]` |

436 438

439### Componenti sperimentali

440

441I componenti sotto la chiave `experimental`, `themes` e `monitors`, hanno uno schema del manifest che potrebbe cambiare tra le versioni mentre si stabilizzano. Il luogo in cui li dichiari è una migrazione separata: il livello superiore funziona ancora, `claude plugin validate` avvisa, e una versione futura richiederà `experimental.*`.

442

437### Configurazione utente443### Configurazione utente

438 444

439Il campo `userConfig` dichiara i valori per i quali Claude Code chiede all'utente quando il plugin è abilitato. Usa questo invece di richiedere agli utenti di modificare manualmente `settings.json`.445Il campo `userConfig` dichiara i valori per i quali Claude Code chiede all'utente quando il plugin è abilitato. Usa questo invece di richiedere agli utenti di modificare manualmente `settings.json`.

469| `multiple` | No | Per il tipo `string`, consenti un array di stringhe |475| `multiple` | No | Per il tipo `string`, consenti un array di stringhe |

470| `min` / `max` | No | Limiti per il tipo `number` |476| `min` / `max` | No | Limiti per il tipo `number` |

471 477

472Ogni valore è disponibile per la sostituzione come `${user_config.KEY}` nelle configurazioni dei server MCP e LSP, nei comandi degli hooks, nei comandi dei monitor e nel contenuto delle skills e degli agents (solo per i valori non sensibili). Tutti i valori vengono esportati ai sottoprocessi del plugin come variabili di ambiente `CLAUDE_PLUGIN_OPTION_<KEY>`.478Ogni valore è disponibile per la sostituzione come `${user_config.KEY}` nelle configurazioni dei server MCP e LSP, nei comandi degli hooks e nei comandi dei monitor. I valori non sensibili possono anche essere sostituiti nel contenuto delle skills e degli agents. Tutti i valori vengono esportati ai sottoprocessi del plugin come variabili di ambiente `CLAUDE_PLUGIN_OPTION_<KEY>`.

473 479

474I valori non sensibili vengono archiviati in `settings.json` sotto `pluginConfigs[<plugin-id>].options`. I valori sensibili vanno al portachiavi di sistema (o `~/.claude/.credentials.json` dove il portachiavi non è disponibile). L'archiviazione del portachiavi è condivisa con i token OAuth e ha un limite totale approssimativo di 2 KB, quindi mantieni i valori sensibili piccoli.480I valori non sensibili vengono archiviati in `settings.json` sotto `pluginConfigs[<plugin-id>].options`. I valori sensibili vanno al portachiavi di sistema (o `~/.claude/.credentials.json` dove il portachiavi non è disponibile). L'archiviazione del portachiavi è condivisa con i token OAuth e ha un limite totale approssimativo di 2 KB, quindi mantieni i valori sensibili piccoli.

475 481

504 510

505### Regole del comportamento del percorso511### Regole del comportamento del percorso

506 512

507Per `skills`, `commands`, `agents`, `outputStyles`, `themes` e `monitors`, un percorso personalizzato sostituisce il valore predefinito. Se il manifest specifica `skills`, la directory predefinita `skills/` non viene scansionata; se specifica `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.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.

508 514

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

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

605 611

606I plugin vengono specificati in uno di due modi:612I plugin vengono specificati in uno di due modi:

607 613

608* Tramite `claude --plugin-dir`, per la durata di una sessione.614* Tramite `claude --plugin-dir` o `claude --plugin-url`, per la durata di una sessione.

609* Tramite un marketplace, installato per sessioni future.615* Tramite un marketplace, installato per sessioni future.

610 616

611Per motivi di sicurezza e verifica, Claude Code copia i plugin del *marketplace* nella **cache dei plugin** locale dell'utente (`~/.claude/plugins/cache`) piuttosto che usarli sul posto. Comprendere questo comportamento è importante quando si sviluppano plugin che fanno riferimento a file esterni.617Per motivi di sicurezza e verifica, Claude Code copia i plugin del *marketplace* nella **cache dei plugin** locale dell'utente (`~/.claude/plugins/cache`) piuttosto che usarli sul posto. Comprendere questo comportamento è importante quando si sviluppano plugin che fanno riferimento a file esterni.

routines.md +69 −17

Details

14 14

15Ogni routine può avere uno o più trigger collegati:15Ogni routine può avere uno o più trigger collegati:

16 16

~~17* **Scheduled**: eseguire su una cadenza ricorrente come oraria, notturna o settimanale~~17* **Scheduled**: eseguire su una cadenza ricorrente come oraria, notturna o settimanale, oppure una volta a un momento futuro specifico

18* **API**: attivare su richiesta inviando un POST HTTP a un endpoint per routine con un token bearer18* **API**: attivare su richiesta inviando un POST HTTP a un endpoint per routine con un token bearer

19* **GitHub**: eseguire automaticamente in risposta agli eventi del repository come pull request o release19* **GitHub**: eseguire automaticamente in risposta agli eventi del repository come pull request o release

20 20

44 44

45## Creare una routine45## Creare una routine

46 46

47Crea una routine dal web, dall'app Desktop o dalla CLI. Tutte e tre le superfici scrivono nello stesso account cloud, quindi una routine che crei nella CLI appare su claude.ai/code/routines immediatamente. Nell'app Desktop, fai clic su **New task** e scegli **New remote task**; scegliere **New local task** crea invece un [local Desktop scheduled task](/it/desktop-scheduled-tasks), che viene eseguito sulla tua macchina e non è una routine.47Crea una routine dal web su [claude.ai/code/routines](https://claude.ai/code/routines), dall'app Desktop o dalla CLI. Tutte e tre le superfici scrivono nello stesso account cloud, quindi una routine che crei in una appare nelle altre immediatamente. Nell'app Desktop, fai clic su **Routines** nella barra laterale, quindi su **New routine**, e scegli **Remote**; scegliere **Local** invece crea un [Desktop scheduled task](/it/desktop-scheduled-tasks), che viene eseguito sulla tua macchina piuttosto che nel cloud.

48 48

49Il modulo di creazione configura il prompt della routine, i repository, l'ambiente, i connector e i trigger.49Il modulo di creazione configura il prompt della routine, i repository, l'ambiente, i connector e i trigger.

50 50

66 </Step>66 </Step>

67 67

68 <Step title="Seleziona i repository">68 <Step title="Seleziona i repository">

69 Aggiungi uno o più repository GitHub per cui Claude possa lavorare. Ogni repository viene clonato all'inizio di un'esecuzione, a partire dal ramo predefinito. Claude crea rami con prefisso `claude/` per le sue modifiche. Per consentire i push a qualsiasi ramo, abilita **Allow unrestricted branch pushes** per quel repository.69 Aggiungi uno o più repository GitHub per cui Claude possa lavorare. Ogni repository viene clonato all'inizio di un'esecuzione, a partire dal ramo predefinito. Claude crea rami con prefisso `claude/` per le sue modifiche.

70 </Step>70 </Step>

71 71

72 <Step title="Seleziona un ambiente">72 <Step title="Seleziona un ambiente">

76 * **Environment variables**: fornisci chiavi API, token o altri segreti che Claude può utilizzare76 * **Environment variables**: fornisci chiavi API, token o altri segreti che Claude può utilizzare

77 * **Setup script**: installa le dipendenze e gli strumenti di cui la routine ha bisogno. Il risultato è [cached](/it/claude-code-on-the-web#environment-caching), quindi lo script non viene rieseguito su ogni sessione77 * **Setup script**: installa le dipendenze e gli strumenti di cui la routine ha bisogno. Il risultato è [cached](/it/claude-code-on-the-web#environment-caching), quindi lo script non viene rieseguito su ogni sessione

78 78

~~79 Un ambiente **Default** è fornito. Per utilizzare un ambiente personalizzato, [creane uno](/it/claude-code-on-the-web#the-cloud-environment) prima di creare la routine.~~79 Un ambiente **Default** è fornito con accesso di rete **Trusted**, che consente l'[insieme predefinito](/it/claude-code-on-the-web#default-allowed-domains) di registri di pacchetti, API di provider cloud, registri di container e domini di sviluppo comuni, ma blocca tutto il resto. Se la tua routine ha bisogno di raggiungere i tuoi servizi o un dominio al di fuori di tale elenco, modifica l'[accesso di rete](/it/claude-code-on-the-web#network-access) dell'ambiente prima di eseguire. Per utilizzare un ambiente separato, [creane uno](/it/claude-code-on-the-web#configure-your-environment) prima.

80 </Step>80 </Step>

81 81

82 <Step title="Seleziona un trigger">82 <Step title="Seleziona un trigger">

84 84

85 <Tabs>85 <Tabs>

86 <Tab title="Schedule">86 <Tab title="Schedule">

87 Scegli una frequenza preimpostata: oraria, giornaliera, giorni feriali o settimanale. Vedi [Add a schedule trigger](#add-a-schedule-trigger) per la gestione del fuso orario, lo sfasamento e gli intervalli cron personalizzati.87 Scegli una frequenza preimpostata per un'esecuzione ricorrente, o pianifica un'esecuzione una tantum in un timestamp specifico. Vedi [Add a schedule trigger](#add-a-schedule-trigger) per la gestione del fuso orario, lo sfasamento, gli intervalli cron personalizzati e le esecuzioni una tantum.

88 </Tab>88 </Tab>

89 89

90 <Tab title="GitHub event">90 <Tab title="GitHub event">

97 </Tabs>97 </Tabs>

98 </Step>98 </Step>

99 99

100 <Step title="Rivedi i connector">100 <Step title="Rivedi i connector e le autorizzazioni">

101 Tutti i tuoi [MCP connectors](/it/mcp) connessi sono inclusi per impostazione predefinita. Rimuovi quelli che la routine non necessita. I connector danno a Claude accesso ai servizi esterni come Slack, Linear o Google Drive durante ogni esecuzione.101 Le schede **Connectors** e **Permissions** in fondo al modulo controllano ciò che la routine può raggiungere.

102

103 Sotto Connectors, tutti i tuoi [MCP connectors](/it/mcp) connessi sono inclusi per impostazione predefinita. Rimuovi quelli che la routine non necessita. Claude può utilizzare ogni strumento da un connector incluso, incluse le scritture, senza chiedere il permesso durante un'esecuzione.

104

105 Sotto Permissions, abilita **Allow unrestricted branch pushes** per qualsiasi repository dove Claude dovrebbe essere in grado di eseguire il push ai rami esistenti invece che solo a quelli con prefisso `claude/`.

102 </Step>106 </Step>

103 107

104 <Step title="Crea la routine">108 <Step title="Crea la routine">

110 114

111### Creare dalla CLI115### Creare dalla CLI

112 116

113Esegui `/schedule` in qualsiasi sessione per creare una routine pianificata in modo conversazionale. Puoi anche passare una descrizione direttamente, come in `/schedule daily PR review at 9am`. Claude esamina le stesse informazioni che il modulo web raccoglie, quindi salva la routine nel tuo account.117Esegui `/schedule` in qualsiasi sessione per creare una routine pianificata in modo conversazionale. Puoi anche passare una descrizione direttamente, per una routine ricorrente come `/schedule daily PR review at 9am` o una una tantum come `/schedule clean up feature flag in one week`. Claude esamina le stesse informazioni che il modulo web raccoglie, quindi salva la routine nel tuo account.

114 118

115`/schedule` nella CLI crea solo routine pianificate. Per aggiungere un trigger API o GitHub, modifica la routine sul web su [claude.ai/code/routines](https://claude.ai/code/routines).119`/schedule` nella CLI crea solo routine pianificate. Per aggiungere un trigger API o GitHub, modifica la routine sul web su [claude.ai/code/routines](https://claude.ai/code/routines).

116 120

117La CLI supporta anche la gestione delle routine esistenti. Esegui `/schedule list` per vedere tutte le routine, `/schedule update` per modificarne una o `/schedule run` per attivarla immediatamente.121La CLI supporta anche la gestione delle routine esistenti. Esegui `/schedule list` per vedere tutte le routine, `/schedule update` per modificarne una, o `/schedule run` per attivarla immediatamente.

~~118~~

119### Creare dall'app Desktop

~~120~~

121Apri la pagina **Schedule** nell'app Desktop, fai clic su **New task** e scegli **New remote task**. L'app Desktop mostra sia i local scheduled task che le routine nella stessa griglia. Vedi [Desktop scheduled tasks](/it/desktop-scheduled-tasks) per i dettagli sull'opzione locale.

122 122

123## Configurare i trigger123## Configurare i trigger

124 124

126 126

127### Aggiungi un trigger di pianificazione127### Aggiungi un trigger di pianificazione

128 128

129Un trigger di pianificazione esegue la routine su una cadenza ricorrente. Scegli una frequenza preimpostata nella sezione **Select a trigger**: oraria, giornaliera, giorni feriali o settimanale. I tempi vengono inseriti nella tua zona locale e convertiti automaticamente, quindi la routine viene eseguita a quell'ora di parete indipendentemente da dove si trova l'infrastruttura cloud.129Un trigger di pianificazione esegue la routine su una cadenza ricorrente, o una sola volta a un momento futuro specifico. Scegli una frequenza preimpostata nella sezione **Select a trigger**: oraria, giornaliera, giorni feriali o settimanale. I tempi vengono inseriti nella tua zona locale e convertiti automaticamente, quindi la routine viene eseguita a quell'ora di parete indipendentemente da dove si trova l'infrastruttura cloud.

130 130

131Le esecuzioni possono iniziare alcuni minuti dopo l'ora pianificata a causa dello sfasamento. L'offset è coerente per ogni routine.131Le esecuzioni possono iniziare alcuni minuti dopo l'ora pianificata a causa dello sfasamento. L'offset è coerente per ogni routine.

132 132

133Per un intervallo personalizzato come ogni due ore o il primo di ogni mese, scegli il preset più vicino nel modulo, quindi esegui `/schedule update` nella CLI per impostare un'espressione cron specifica. L'intervallo minimo è un'ora; le espressioni che vengono eseguite più frequentemente vengono rifiutate.133Per un intervallo personalizzato come ogni due ore o il primo di ogni mese, scegli il preset più vicino nel modulo, quindi esegui `/schedule update` nella CLI per impostare un'espressione cron specifica. L'intervallo minimo è un'ora; le espressioni che vengono eseguite più frequentemente vengono rifiutate.

134 134

135#### Pianifica un'esecuzione una tantum

136

137Una pianificazione una tantum attiva la routine una sola volta a un timestamp specifico. Usala per ricordarti più tardi nella settimana, per aprire una PR di pulizia dopo che un rollout finisce, o per avviare un'attività di follow-up quando un cambiamento upstream arriva. Dopo che la routine si attiva, si disabilita automaticamente e l'interfaccia utente web la contrassegna come **Ran**. Per eseguirla di nuovo, modifica la routine e imposta un nuovo orario una tantum.

138

139Crea un'esecuzione una tantum dalla CLI descrivendo l'ora in linguaggio naturale. Claude risolve la frase rispetto all'ora attuale e conferma il timestamp assoluto prima di salvare.

140

141```text theme={null}

142/schedule tomorrow at 9am, summarize yesterday's merged PRs

143```

144

145```text theme={null}

146/schedule in 2 weeks, open a cleanup PR that removes the feature flag

147```

148

149La stessa conversione da locale a UTC come per le pianificazioni ricorrenti si applica ai timestamp una tantum.

150

151Le esecuzioni una tantum non contano rispetto al limite di esecuzione della routine giornaliera. Consumano l'utilizzo della sottoscrizione regolare del tuo piano come qualsiasi altra sessione. Vedi [Usage and limits](#usage-and-limits) per i dettagli.

152

135### Aggiungi un trigger API153### Aggiungi un trigger API

136 154

137Un trigger API fornisce a una routine un endpoint HTTP dedicato. POSTing all'endpoint con il token bearer della routine avvia una nuova sessione e restituisce un URL di sessione. Usalo per collegare Claude Code nei sistemi di avviso, pipeline di distribuzione, strumenti interni o ovunque tu possa fare una richiesta HTTP autenticata.155Un trigger API fornisce a una routine un endpoint HTTP dedicato. POSTing all'endpoint con il token bearer della routine avvia una nuova sessione e restituisce un URL di sessione. Usalo per collegare Claude Code nei sistemi di avviso, pipeline di distribuzione, strumenti interni o ovunque tu possa fare una richiesta HTTP autenticata.

144 </Step>162 </Step>

145 163

146 <Step title="Aggiungi un trigger API">164 <Step title="Aggiungi un trigger API">

147 Scorri fino alla sezione **Select a trigger** sotto il prompt, fai clic su **Add another trigger** e scegli **API**.165 Scorri fino alla sezione **Select a trigger** sotto il box **Instructions**, fai clic su **Add another trigger** e scegli **API**.

148 </Step>166 </Step>

149 167

150 <Step title="Copia l'URL e genera un token">168 <Step title="Copia l'URL e genera un token">

273 291

274Fai clic su qualsiasi esecuzione per aprirla come sessione completa. Da lì puoi vedere cosa ha fatto Claude, rivedere le modifiche, creare una pull request o continuare la conversazione. Ogni sessione di esecuzione funziona come qualsiasi altra sessione: usa il menu a discesa accanto al titolo della sessione per rinominare, archiviare o eliminare.292Fai clic su qualsiasi esecuzione per aprirla come sessione completa. Da lì puoi vedere cosa ha fatto Claude, rivedere le modifiche, creare una pull request o continuare la conversazione. Ogni sessione di esecuzione funziona come qualsiasi altra sessione: usa il menu a discesa accanto al titolo della sessione per rinominare, archiviare o eliminare.

275 293

294<Note>

295 Uno stato verde nell'elenco delle esecuzioni significa che la sessione è stata avviata e chiusa senza un errore di infrastruttura. Non significa che l'attività nel tuo prompt sia riuscita. Apri l'esecuzione per leggere la trascrizione e confermare cosa ha effettivamente fatto Claude. Le richieste di rete bloccate, gli strumenti connector mancanti e i guasti a livello di attività vengono visualizzati lì piuttosto che nell'indicatore di stato.

296</Note>

297

276### Modifica e controlla le routine298### Modifica e controlla le routine

277 299

278Dalla pagina dei dettagli della routine puoi:300Dalla pagina dei dettagli della routine puoi:

298 320

299Per gestire o aggiungere connector al di fuori del modulo della routine, visita **Settings > Connectors** su claude.ai o usa `/schedule update` nella CLI.321Per gestire o aggiungere connector al di fuori del modulo della routine, visita **Settings > Connectors** su claude.ai o usa `/schedule update` nella CLI.

300 322

301### Ambienti323### Ambienti e accesso di rete

324

325Ogni routine viene eseguita in un [cloud environment](/it/claude-code-on-the-web#the-cloud-environment) che controlla l'accesso di rete, le variabili di ambiente e gli script di configurazione. La routine eredita la politica di rete dell'ambiente su ogni esecuzione.

302 326

303Ogni routine viene eseguita in un [cloud environment](/it/claude-code-on-the-web#the-cloud-environment) che controlla l'accesso di rete, le variabili di ambiente e gli script di configurazione. Configura gli ambienti prima di creare una routine per dare a Claude accesso alle API, installare dipendenze o limitare l'ambito di rete. Vedi [cloud environment](/it/claude-code-on-the-web#the-cloud-environment) per la guida di configurazione completa.327L'ambiente **Default** utilizza l'accesso di rete **Trusted**: l'[elenco di autorizzazione predefinito](/it/claude-code-on-the-web#default-allowed-domains) dei registri di pacchetti, delle API dei provider cloud, dei registri di container e dei domini di sviluppo comuni è raggiungibile, ma i domini arbitrari non lo sono. Le richieste in uscita verso altri host non riescono con `403` e `x-deny-reason: host_not_allowed`. Il traffico del connector MCP viene instradato attraverso i server di Anthropic, quindi i connector che aggiungi alla routine funzionano senza aggiungere i loro host ai **Allowed domains**. Rimuovi eventuali connector che non ti servono in [Connector](#connector).

328

329Per consentire domini aggiuntivi:

330

331<Steps>

332 <Step title="Apri la routine per la modifica">

333 Sulla pagina dei dettagli della routine, fai clic sull'icona della matita per aprire **Edit routine**.

334 </Step>

335

336 <Step title="Apri il selettore di ambiente">

337 Sotto la casella **Instructions**, seleziona l'icona cloud che mostra il nome del tuo ambiente, ad esempio **Default**.

338 </Step>

339

340 <Step title="Apri le impostazioni dell'ambiente">

341 Passa il mouse sull'ambiente nell'elenco e fai clic sull'icona delle impostazioni che appare a destra.

342 </Step>

343

344 <Step title="Modifica il livello di accesso di rete">

345 Nella finestra di dialogo **Update cloud environment**, modifica **Network access** in **Custom** e inserisci i tuoi domini in **Allowed domains**. Seleziona **Also include default list of common package managers** per mantenere l'[elenco di autorizzazione predefinito](/it/claude-code-on-the-web#default-allowed-domains) insieme ai tuoi domini personalizzati. Seleziona invece **Full** per l'accesso senza restrizioni.

346 </Step>

347

348 <Step title="Salva">

349 Fai clic su **Save changes**. La nuova politica si applica dalla prossima esecuzione.

350 </Step>

351</Steps>

352

353Vedi [Network access](/it/claude-code-on-the-web#network-access) per i dettagli sui livelli di accesso e l'elenco di autorizzazione predefinito.

304 354

305## Utilizzo e limiti355## Utilizzo e limiti

306 356

308 358

309Quando una routine raggiunge il limite giornaliero o il limite di utilizzo dell'abbonamento, le organizzazioni con utilizzo extra abilitato possono continuare a eseguire routine su eccedenza misurata. Senza utilizzo extra, le esecuzioni aggiuntive vengono rifiutate fino al ripristino della finestra. Abilita l'utilizzo extra da **Settings > Billing** su claude.ai.359Quando una routine raggiunge il limite giornaliero o il limite di utilizzo dell'abbonamento, le organizzazioni con utilizzo extra abilitato possono continuare a eseguire routine su eccedenza misurata. Senza utilizzo extra, le esecuzioni aggiuntive vengono rifiutate fino al ripristino della finestra. Abilita l'utilizzo extra da **Settings > Billing** su claude.ai.

310 360

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.

362

311## Risorse correlate363## Risorse correlate

312 364

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

settings.md +19 −15

Details

164| `allowManagedHooksOnly` | (Solo impostazioni gestite) Solo gli hook gestiti, gli hook SDK e gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati. Vedi [Configurazione hook](#hook-configuration) | `true` |164| `allowManagedHooksOnly` | (Solo impostazioni gestite) Solo gli hook gestiti, gli hook SDK e gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati. Vedi [Configurazione hook](#hook-configuration) | `true` |

165| `allowManagedMcpServersOnly` | (Solo impostazioni gestite) Solo `allowedMcpServers` dalle impostazioni gestite sono rispettati. `deniedMcpServers` si unisce comunque da tutte le fonti. Gli utenti possono ancora aggiungere MCP server, ma si applica solo l'elenco di autorizzazione definito dall'amministratore. Vedi [Configurazione MCP gestita](/it/mcp#managed-mcp-configuration) | `true` |165| `allowManagedMcpServersOnly` | (Solo impostazioni gestite) Solo `allowedMcpServers` dalle impostazioni gestite sono rispettati. `deniedMcpServers` si unisce comunque da tutte le fonti. Gli utenti possono ancora aggiungere MCP server, ma si applica solo l'elenco di autorizzazione definito dall'amministratore. Vedi [Configurazione MCP gestita](/it/mcp#managed-mcp-configuration) | `true` |

166| `allowManagedPermissionRulesOnly` | (Solo impostazioni gestite) Previeni che le impostazioni utente e di progetto definiscano regole di permesso `allow`, `ask` o `deny`. Si applicano solo le regole nelle impostazioni gestite. Vedi [Impostazioni solo gestite](/it/permissions#managed-only-settings) | `true` |166| `allowManagedPermissionRulesOnly` | (Solo impostazioni gestite) Previeni che le impostazioni utente e di progetto definiscano regole di permesso `allow`, `ask` o `deny`. Si applicano solo le regole nelle impostazioni gestite. Vedi [Impostazioni solo gestite](/it/permissions#managed-only-settings) | `true` |

167| `alwaysThinkingEnabled` | Abilita il [pensiero esteso](/it/model-config#extended-thinking) per impostazione predefinita per tutte le sessioni. Tipicamente configurato tramite il comando `/config` piuttosto che modificato direttamente | `true` |167| `alwaysThinkingEnabled` | Abilita il [pensiero esteso](/it/model-config#extended-thinking) per impostazione predefinita per tutte le sessioni. Tipicamente configurato tramite il comando `/config` piuttosto che modificato direttamente. Per forzare il pensiero disattivato indipendentemente da questa impostazione, imposta [`CLAUDE_CODE_DISABLE_THINKING`](/it/env-vars) in `env` | `true` |

168| `apiKeyHelper` | Script personalizzato, da eseguire in `/bin/sh`, per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello | `/bin/generate_temp_api_key.sh` |168| `apiKeyHelper` | Script personalizzato, da eseguire in `/bin/sh`, per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](/it/env-vars) | `/bin/generate_temp_api_key.sh` |

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 | `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` 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"]}` |

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

176| `awaySummaryEnabled` | Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Imposta a `false` o disattiva Riepilogo sessione in `/config` per disabilitare. Uguale a [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](/it/env-vars) | `true` |176| `awaySummaryEnabled` | Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Imposta a `false` o disattiva Riepilogo sessione in `/config` per disabilitare. Uguale a [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](/it/env-vars) | `true` |

177| `awsAuthRefresh` | Script personalizzato che modifica la directory `.aws` (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |177| `awsAuthRefresh` | Script personalizzato che modifica la directory `.aws` (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |

178| `awsCredentialExport` | Script personalizzato che restituisce JSON con le credenziali AWS (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |178| `awsCredentialExport` | Script personalizzato che restituisce JSON con le credenziali AWS (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |

179| `blockedMarketplaces` | (Solo impostazioni gestite) Elenco di negazione delle fonti del marketplace. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Le fonti bloccate vengono controllate prima del download, quindi non toccano mai il filesystem. Vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |179| `blockedMarketplaces` | (Solo impostazioni gestite) Elenco di negazione delle fonti del marketplace. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Le fonti bloccate vengono controllate prima del download, quindi non toccano mai il filesystem. Vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |

180| `channelsEnabled` | (Solo impostazioni gestite) Consenti [channels](/it/channels) per l'organizzazione. Nei piani Team e Enterprise di claude.ai, i canali vengono bloccati quando questo non è impostato o è `false`. Per gli account [Anthropic Console](/it/authentication#claude-console-authentication) che utilizzano l'autenticazione con chiave API, i canali sono consentiti per impostazione predefinita a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso questa chiave deve essere impostata a `true` | `true` |180| `channelsEnabled` | (Solo impostazioni gestite) Consenti [channels](/it/channels) per l'organizzazione. Nei piani Team e Enterprise di claude.ai, i canali vengono bloccati quando questo non è impostato o è `false`. Per gli account [Anthropic Console](/it/authentication#claude-console-authentication) che utilizzano l'autenticazione con chiave API, i canali sono consentiti per impostazione predefinita a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso questa chiave deve essere impostata a `true` | `true` |

181| `claudeMdExcludes` | Modelli Glob o percorsi assoluti dei file `CLAUDE.md` da saltare durante il caricamento della [memoria](/it/memory). I modelli corrispondono ai percorsi assoluti dei file. Si applica solo alla memoria utente, progetto e locale; i file di politica gestiti non possono essere esclusi | `["**/vendor/**/CLAUDE.md"]` |

181| `cleanupPeriodDays` | I file di sessione più vecchi di questo periodo vengono eliminati all'avvio (predefinito: 30 giorni, minimo 1). L'impostazione a `0` viene rifiutata con un errore di convalida. Controlla anche il limite di età per la rimozione automatica dei [worktrees subagent orfani](/it/worktrees#clean-up-worktrees) all'avvio. Per disabilitare completamente le scritture di trascritti, imposta la variabile di ambiente [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/it/env-vars), o in modalità non interattiva (`-p`) usa il flag `--no-session-persistence` o l'opzione SDK `persistSession: false`. | `20` |182| `cleanupPeriodDays` | I file di sessione più vecchi di questo periodo vengono eliminati all'avvio (predefinito: 30 giorni, minimo 1). L'impostazione a `0` viene rifiutata con un errore di convalida. Controlla anche il limite di età per la rimozione automatica dei [worktrees subagent orfani](/it/worktrees#clean-up-worktrees) all'avvio. Per disabilitare completamente le scritture di trascritti, imposta la variabile di ambiente [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/it/env-vars), o in modalità non interattiva (`-p`) usa il flag `--no-session-persistence` o l'opzione SDK `persistSession: false`. | `20` |

182| `companyAnnouncements` | Annuncio da visualizzare agli utenti all'avvio. Se vengono forniti più annunci, verranno alternati casualmente. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |183| `companyAnnouncements` | Annuncio da visualizzare agli utenti all'avvio. Se vengono forniti più annunci, verranno alternati casualmente. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |

183| `defaultShell` | Shell predefinita per i comandi `!` della casella di input. Accetta `"bash"` (predefinito) o `"powershell"`. L'impostazione a `"powershell"` instrada i comandi `!` interattivi tramite PowerShell su Windows. Richiede `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Vedi [Strumento PowerShell](/it/tools-reference#powershell-tool) | `"powershell"` |184| `defaultShell` | Shell predefinita per i comandi `!` della casella di input. Accetta `"bash"` (predefinito) o `"powershell"`. L'impostazione a `"powershell"` instrada i comandi `!` interattivi tramite PowerShell su Windows. Richiede `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Vedi [Strumento PowerShell](/it/tools-reference#powershell-tool) | `"powershell"` |

189| `disableRemoteControl` | {/* min-version: 2.1.128 */}Disabilita il [Controllo remoto](/it/remote-control): blocca `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione. Tipicamente posizionato nelle [impostazioni gestite](/it/permissions#managed-settings) per l'applicazione MDM per dispositivo, ma funziona da qualsiasi ambito. Richiede Claude Code v2.1.128 o successivo | `true` |190| `disableRemoteControl` | {/* min-version: 2.1.128 */}Disabilita il [Controllo remoto](/it/remote-control): blocca `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione. Tipicamente posizionato nelle [impostazioni gestite](/it/permissions#managed-settings) per l'applicazione MDM per dispositivo, ma funziona da qualsiasi ambito. Richiede Claude Code v2.1.128 o successivo | `true` |

190| `disableSkillShellExecution` | Disabilita l'esecuzione inline della shell per i blocchi `` !`...` `` e ` ```! ` nei [skills](/it/skills) e nei comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntive. I comandi vengono sostituiti con `[shell command execution disabled by policy]` invece di essere eseguiti. I skills bundled e gestiti non sono interessati. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `true` |191| `disableSkillShellExecution` | Disabilita l'esecuzione inline della shell per i blocchi `` !`...` `` e ` ```! ` nei [skills](/it/skills) e nei comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntive. I comandi vengono sostituiti con `[shell command execution disabled by policy]` invece di essere eseguiti. I skills bundled e gestiti non sono interessati. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `true` |

191| `editorMode` | Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Predefinito: `"normal"`. Appare in `/config` come **Editor mode** | `"vim"` |192| `editorMode` | Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Predefinito: `"normal"`. Appare in `/config` come **Editor mode** | `"vim"` |

192| `effortLevel` | Persisti il [livello di sforzo](/it/model-config#adjust-effort-level) tra le sessioni. Accetta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Scritto automaticamente quando esegui `/effort` con uno di questi valori. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) per i modelli supportati | `"xhigh"` |193| `effortLevel` | Persisti il [livello di sforzo](/it/model-config#adjust-effort-level) tra le sessioni. Accetta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Scritto automaticamente quando esegui `/effort` con uno di questi valori. `--effort` e [`CLAUDE_CODE_EFFORT_LEVEL`](/it/env-vars) ignorano questo per una sessione. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) per i modelli supportati | `"xhigh"` |

195| `env` | Variabili di ambiente che verranno applicate a ogni sessione | `{"FOO": "bar"}` |196| `env` | Variabili di ambiente che verranno applicate a ogni sessione | `{"FOO": "bar"}` |

196| `fastModePerSessionOptIn` | Quando `true`, la modalità veloce non persiste tra le sessioni. Ogni sessione inizia con la modalità veloce disattivata, richiedendo agli utenti di abilitarla con `/fast`. La preferenza della modalità veloce dell'utente viene comunque salvata. Vedi [Richiedi opt-in per sessione](/it/fast-mode#require-per-session-opt-in) | `true` |197| `fastModePerSessionOptIn` | Quando `true`, la modalità veloce non persiste tra le sessioni. Ogni sessione inizia con la modalità veloce disattivata, richiedendo agli utenti di abilitarla con `/fast`. La preferenza della modalità veloce dell'utente viene comunque salvata. Vedi [Richiedi opt-in per sessione](/it/fast-mode#require-per-session-opt-in) | `true` |

197| `feedbackSurveyRate` | Probabilità (0–1) che il [sondaggio sulla qualità della sessione](/it/data-usage#session-quality-surveys) appaia quando idoneo. Imposta a `0` per sopprimere completamente. Utile quando si utilizza Bedrock, Vertex, o Foundry dove il tasso di campionamento predefinito non si applica | `0.05` |198| `feedbackSurveyRate` | Probabilità (0–1) che il [sondaggio sulla qualità della sessione](/it/data-usage#session-quality-surveys) appaia quando idoneo. Imposta a `0` per sopprimere completamente, o imposta [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](/it/env-vars) in `env`. Utile quando si utilizza Bedrock, Vertex, o Foundry dove il tasso di campionamento predefinito non si applica | `0.05` |

198| `fileSuggestion` | Configura uno script personalizzato per l'autocompletamento dei file `@`. Vedi [Impostazioni di suggerimento file](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |199| `fileSuggestion` | Configura uno script personalizzato per l'autocompletamento dei file `@`. Vedi [Impostazioni di suggerimento file](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |

199| `forceLoginMethod` | Usa `claudeai` per limitare l'accesso agli account Claude.ai, `console` per limitare l'accesso agli account Claude Console (fatturazione per utilizzo API) | `claudeai` |200| `forceLoginMethod` | Usa `claudeai` per limitare l'accesso agli account Claude.ai, `console` per limitare l'accesso agli account Claude Console (fatturazione per utilizzo API) | `claudeai` |

200| `forceLoginOrgUUID` | Richiedi che l'accesso appartenga a un'organizzazione specifica. Accetta una singola stringa UUID, che pre-seleziona anche quell'organizzazione durante l'accesso, o un array di UUID dove qualsiasi organizzazione elencata è accettata senza pre-selezione. Quando impostato nelle impostazioni gestite, l'accesso fallisce se l'account autenticato non appartiene a un'organizzazione elencata; un array vuoto fallisce in modo chiuso e blocca l'accesso con un messaggio di errore di configurazione | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |201| `forceLoginOrgUUID` | Richiedi che l'accesso appartenga a un'organizzazione specifica. Accetta una singola stringa UUID, che pre-seleziona anche quell'organizzazione durante l'accesso, o un array di UUID dove qualsiasi organizzazione elencata è accettata senza pre-selezione. Quando impostato nelle impostazioni gestite, l'accesso fallisce se l'account autenticato non appartiene a un'organizzazione elencata; un array vuoto fallisce in modo chiuso e blocca l'accesso con un messaggio di errore di configurazione | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |

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

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

203| `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 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"]` |

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

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

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

207| `minimumVersion` | Floor che previene l'auto-aggiornamento in background e `claude update` dall'installazione di una versione al di sotto di questa. Passare dal canale `"latest"` a `"stable"` tramite `/config` ti chiede di rimanere sulla versione corrente o di consentire il downgrade. Scegliere di rimanere imposta questo valore. Utile anche nelle [impostazioni gestite](/it/permissions#managed-settings) per fissare un minimo a livello organizzativo | `"2.1.100"` |209| `minimumVersion` | Floor che previene l'auto-aggiornamento in background e `claude update` dall'installazione di una versione al di sotto di questa. Passare dal canale `"latest"` a `"stable"` tramite `/config` ti chiede di rimanere sulla versione corrente o di consentire il downgrade. Scegliere di rimanere imposta questo valore. Utile anche nelle [impostazioni gestite](/it/permissions#managed-settings) per fissare un minimo a livello organizzativo | `"2.1.100"` |

209| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |211| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |

210| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente (vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers)) | `/bin/generate_otel_headers.sh` |212| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/it/env-vars). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |

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

219| `showClearContextOnPlanAccept` | Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Predefinito: `false`. Imposta a `true` per ripristinare l'opzione | `true` |221| `showClearContextOnPlanAccept` | Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Predefinito: `false`. Imposta a `true` per ripristinare l'opzione | `true` |

220| `showThinkingSummaries` | Mostra i riassunti del [pensiero esteso](/it/model-config#extended-thinking) nelle sessioni interattive. Quando non impostato o `false` (predefinito in modalità interattiva), i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, [abbassa il budget o disabilita il pensiero](/it/model-config#extended-thinking) invece. La modalità non interattiva (`-p`) e i chiamanti SDK ricevono sempre i riassunti indipendentemente da questa impostazione | `true` |222| `showThinkingSummaries` | Mostra i riassunti del [pensiero esteso](/it/model-config#extended-thinking) nelle sessioni interattive. Quando non impostato o `false` (predefinito in modalità interattiva), i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, [abbassa il budget o disabilita il pensiero](/it/model-config#extended-thinking) invece. La modalità non interattiva (`-p`) e i chiamanti SDK ricevono sempre i riassunti indipendentemente da questa impostazione | `true` |

221| `showTurnDuration` | Mostra i messaggi di durata del turno dopo le risposte, ad es. "Cooked for 1m 6s". Predefinito: `true`. Appare in `/config` come **Show turn duration** | `false` |223| `showTurnDuration` | Mostra i messaggi di durata del turno dopo le risposte, ad es. "Cooked for 1m 6s". Predefinito: `true`. Appare in `/config` come **Show turn duration** | `false` |

224| `skillOverrides` | {/* min-version: 2.1.129 */}Override di visibilità per skill, con chiave il nome dello skill. Il valore è `"on"`, `"name-only"`, `"user-invocable-only"`, o `"off"`. Ti consente di nascondere o comprimere uno skill senza modificare il suo SKILL.md. Non si applica ai plugin skills, che vengono gestiti tramite `/plugin`. Il menu `/skills` scrive questi in `.claude/settings.local.json`. Vedi [Override della visibilità dello skill dalle impostazioni](/it/skills#override-skill-visibility-from-settings). Richiede Claude Code v2.1.129 o successivo | `{"legacy-context": "name-only", "deploy": "off"}` |

222| `skipWebFetchPreflight` | Salta il [controllo di sicurezza del dominio WebFetch](/it/data-usage#webfetch-domain-safety-check) che invia ogni hostname richiesto a `api.anthropic.com` prima del recupero. Imposta a `true` negli ambienti che bloccano il traffico verso Anthropic, come le distribuzioni Bedrock, Vertex AI, o Foundry con egress restrittivo. Quando saltato, WebFetch tenta qualsiasi URL senza consultare l'elenco di blocco | `true` |225| `skipWebFetchPreflight` | Salta il [controllo di sicurezza del dominio WebFetch](/it/data-usage#webfetch-domain-safety-check) che invia ogni hostname richiesto a `api.anthropic.com` prima del recupero. Imposta a `true` negli ambienti che bloccano il traffico verso Anthropic, come le distribuzioni Bedrock, Vertex AI, o Foundry con egress restrittivo. Quando saltato, WebFetch tenta qualsiasi URL senza consultare l'elenco di blocco | `true` |

223| `spinnerTipsEnabled` | Mostra suggerimenti nello spinner mentre Claude sta lavorando. Imposta a `false` per disabilitare i suggerimenti (predefinito: `true`) | `false` |226| `spinnerTipsEnabled` | Mostra suggerimenti nello spinner mentre Claude sta lavorando. Imposta a `false` per disabilitare i suggerimenti (predefinito: `true`) | `false` |

224| `spinnerTipsOverride` | Ignora i suggerimenti dello spinner con stringhe personalizzate. `tips`: array di stringhe di suggerimento. `excludeDefault`: se `true`, mostra solo suggerimenti personalizzati; se `false` o assente, i suggerimenti personalizzati vengono uniti ai suggerimenti incorporati | `{ "excludeDefault": true, "tips": ["Use our internal tool X"] }` |227| `spinnerTipsOverride` | Ignora i suggerimenti dello spinner con stringhe personalizzate. `tips`: array di stringhe di suggerimento. `excludeDefault`: se `true`, mostra solo suggerimenti personalizzati; se `false` o assente, i suggerimenti personalizzati vengono uniti ai suggerimenti incorporati | `{ "excludeDefault": true, "tips": ["Use our internal tool X"] }` |

226| `sshConfigs` | Connessioni SSH da mostrare nel menu a discesa dell'ambiente [Desktop](/it/desktop#pre-configure-ssh-connections-for-your-team). Ogni voce richiede `id`, `name` e `sshHost`; `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Quando impostato nelle impostazioni gestite, le connessioni sono di sola lettura per gli utenti. Letto solo dalle impostazioni gestite e utente | `[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]` |229| `sshConfigs` | Connessioni SSH da mostrare nel menu a discesa dell'ambiente [Desktop](/it/desktop#pre-configure-ssh-connections-for-your-team). Ogni voce richiede `id`, `name` e `sshHost`; `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Quando impostato nelle impostazioni gestite, le connessioni sono di sola lettura per gli utenti. Letto solo dalle impostazioni gestite e utente | `[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]` |

227| `statusLine` | Configura una status line personalizzata per visualizzare il contesto. Vedi [documentazione `statusLine`](/it/statusline) | `{"type": "command", "command": "~/.claude/statusline.sh"}` |230| `statusLine` | Configura una status line personalizzata per visualizzare il contesto. Vedi [documentazione `statusLine`](/it/statusline) | `{"type": "command", "command": "~/.claude/statusline.sh"}` |

228| `strictKnownMarketplaces` | (Solo impostazioni gestite) Elenco di autorizzazione dei marketplace dei plugin. Non definito = nessuna restrizione, array vuoto = blocco. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |231| `strictKnownMarketplaces` | (Solo impostazioni gestite) Elenco di autorizzazione dei marketplace dei plugin. Non definito = nessuna restrizione, array vuoto = blocco. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |

229| `teammateMode` | Come i compagni di squadra del [team di agenti](/it/agent-teams) vengono visualizzati: `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `in-process`, o `tmux`. Vedi [scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `"in-process"` |232| `syntaxHighlightingDisabled` | Disabilita l'evidenziazione della sintassi nei diff, nei blocchi di codice e nelle anteprime dei file | `true` |

233| `teammateMode` | Come i compagni di squadra del [team di agenti](/it/agent-teams) vengono visualizzati: `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `in-process`, o `tmux`. `--teammate-mode` ignora questo per una sessione. Vedi [scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `"in-process"` |

230| `terminalProgressBarEnabled` | Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Predefinito: `true`. Appare in `/config` come **Terminal progress bar** | `false` |234| `terminalProgressBarEnabled` | Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Predefinito: `true`. Appare in `/config` come **Terminal progress bar** | `false` |

231| `tui` | Renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer [alt-screen](/it/fullscreen) senza sfarfallio con scrollback virtualizzato. Usa `"default"` per il renderer classico della schermata principale. Imposta tramite `/tui` | `"fullscreen"` |235| `tui` | Renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer [alt-screen](/it/fullscreen) senza sfarfallio con scrollback virtualizzato. Usa `"default"` per il renderer classico della schermata principale. Imposta tramite `/tui`. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_NO_FLICKER`](/it/env-vars) | `"fullscreen"` |

232| `useAutoModeDuringPlan` | Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Predefinito: `true`. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan" | `false` |236| `useAutoModeDuringPlan` | Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Predefinito: `true`. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan" | `false` |

233| `viewMode` | Modalità di visualizzazione della trascrizione predefinita all'avvio: `"default"`, `"verbose"`, o `"focus"`. Ignora la selezione sticky `/focus` quando impostato | `"verbose"` |237| `viewMode` | Modalità di visualizzazione della trascrizione predefinita all'avvio: `"default"`, `"verbose"`, o `"focus"`. Ignora la selezione sticky `/focus` quando impostato. Il flag `--verbose` ignora questo per una sessione | `"verbose"` |

234| `voice` | Impostazioni della [dettatura vocale](/it/voice-dictation): `enabled` attiva la dettatura, `mode` seleziona `"hold"` o `"tap"`, e `autoSubmit` invia il prompt al rilascio del tasto in modalità hold. Scritto automaticamente quando esegui `/voice`. Richiede un account Claude.ai | `{ "enabled": true, "mode": "tap" }` |238| `voice` | Impostazioni della [dettatura vocale](/it/voice-dictation): `enabled` attiva la dettatura, `mode` seleziona `"hold"` o `"tap"`, e `autoSubmit` invia il prompt al rilascio del tasto in modalità hold. Scritto automaticamente quando esegui `/voice`. Richiede un account Claude.ai | `{ "enabled": true, "mode": "tap" }` |

236| `wslInheritsWindowsSettings` | (Solo impostazioni gestite Windows) Quando `true`, Claude Code su WSL legge le impostazioni gestite dalla catena di politiche Windows in aggiunta a `/etc/claude-code`, con le fonti Windows che hanno priorità. Onorato solo quando impostato nella chiave di registro HKLM o in `C:\Program Files\ClaudeCode\managed-settings.json`, entrambi richiedono privilegi di amministratore Windows per scrivere. Affinché la politica HKCU si applichi anche su WSL, il flag deve essere impostato anche in HKCU stesso. Non ha effetto su Windows nativo | `true` |240| `wslInheritsWindowsSettings` | (Solo impostazioni gestite Windows) Quando `true`, Claude Code su WSL legge le impostazioni gestite dalla catena di politiche Windows in aggiunta a `/etc/claude-code`, con le fonti Windows che hanno priorità. Onorato solo quando impostato nella chiave di registro HKLM o in `C:\Program Files\ClaudeCode\managed-settings.json`, entrambi richiedono privilegi di amministratore Windows per scrivere. Affinché la politica HKCU si applichi anche su WSL, il flag deve essere impostato anche in HKCU stesso. Non ha effetto su Windows nativo | `true` |

244</Note>248</Note>

245 249

247| :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------ |251| :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------ |

248| `autoConnectIde` | Connettiti automaticamente a un IDE in esecuzione quando Claude Code si avvia da un terminale esterno. Predefinito: `false`. Appare in `/config` come **Auto-connect to IDE (external terminal)** quando eseguito al di fuori di un terminale VS Code o JetBrains | `true` |252| `autoConnectIde` | Connettiti automaticamente a un IDE in esecuzione quando Claude Code si avvia da un terminale esterno. Predefinito: `false`. Appare in `/config` come **Auto-connect to IDE (external terminal)** quando eseguito al di fuori di un terminale VS Code o JetBrains. La variabile di ambiente [`CLAUDE_CODE_AUTO_CONNECT_IDE`](/it/env-vars) ignora questo quando impostata | `true` |

249| `autoInstallIdeExtension` | Installa automaticamente l'estensione IDE di Claude Code quando eseguito da un terminale VS Code. Predefinito: `true`. Appare in `/config` come **Auto-install IDE extension** quando eseguito all'interno di un terminale VS Code o JetBrains. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](/it/env-vars) | `false` |253| `autoInstallIdeExtension` | Installa automaticamente l'estensione IDE di Claude Code quando eseguito da un terminale VS Code. Predefinito: `true`. Appare in `/config` come **Auto-install IDE extension** quando eseguito all'interno di un terminale VS Code o JetBrains. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](/it/env-vars) | `false` |

250| `externalEditorContext` | Prependi la risposta precedente di Claude come contesto commentato con `#` quando apri l'editor esterno con `Ctrl+G`. Predefinito: `false`. Appare in `/config` come **Show last response in external editor** | `true` |254| `externalEditorContext` | Prependi la risposta precedente di Claude come contesto commentato con `#` quando apri l'editor esterno con `Ctrl+G`. Predefinito: `false`. Appare in `/config` come **Show last response in external editor** | `true` |

251 255

444 448

445**Limita gli URL degli hook HTTP:**449**Limita gli URL degli hook HTTP:**

446 450

447Limita quali URL gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly per la corrispondenza. Quando l'array è definito, gli hook HTTP che indirizzano URL non corrispondenti vengono silenziosamente bloccati.451Limita quali URL gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly per la corrispondenza. Quando l'array è definito, gli hook HTTP che indirizzano URL non corrispondenti vengono silenziosamente bloccati. La corrispondenza del nome host non distingue tra maiuscole e minuscole e ignora un punto FQDN finale, corrispondendo alla semantica DNS.

448 452

449```json theme={null}453```json theme={null}

450{454{

472 * All'interno del livello gestito, la precedenza è: gestite dal server > politiche MDM/a livello di sistema operativo > file-based (`managed-settings.d/*.json` + `managed-settings.json`) > registro HKCU (solo Windows). Viene utilizzata una sola fonte gestita; le fonti non si uniscono tra i livelli. All'interno del livello file-based, i file drop-in e il file base vengono uniti insieme.476 * All'interno del livello gestito, la precedenza è: gestite dal server > politiche MDM/a livello di sistema operativo > file-based (`managed-settings.d/*.json` + `managed-settings.json`) > registro HKCU (solo Windows). Viene utilizzata una sola fonte gestita; le fonti non si uniscono tra i livelli. All'interno del livello file-based, i file drop-in e il file base vengono uniti insieme.

473 477

4742. **Argomenti della riga di comando**4782. **Argomenti della riga di comando**

475 * Override temporanei per una sessione specifica479 * Override temporanei per una sessione specifica. JSON passato tramite `--settings <file-or-json>` si unisce con le impostazioni basate su file utilizzando le stesse regole degli altri livelli: una chiave impostata qui ignora la stessa chiave nelle impostazioni locale, di progetto o utente, e omettere una chiave lascia il valore del livello inferiore in posizione

476 480

4773. **Impostazioni di progetto locale** (`.claude/settings.local.json`)4813. **Impostazioni di progetto locale** (`.claude/settings.local.json`)

478 * Impostazioni personali specifiche del progetto482 * Impostazioni personali specifiche del progetto

setup.md +7 −3

Details

175 175

176## Aggiornare Claude Code176## Aggiornare Claude Code

177 177

178Le installazioni native si aggiornano automaticamente in background. Potete [configurare il canale di rilascio](#configure-release-channel) per controllare se ricevere gli aggiornamenti immediatamente o secondo una pianificazione stabile ritardata, oppure [disabilitare gli aggiornamenti automatici](#disable-auto-updates) completamente. Le installazioni Homebrew, WinGet e [gestori di pacchetti Linux](#install-with-linux-package-managers) richiedono aggiornamenti manuali.178Le installazioni native si aggiornano automaticamente in background. Potete [configurare il canale di rilascio](#configure-release-channel) per controllare se ricevere gli aggiornamenti immediatamente o secondo una pianificazione stabile ritardata, oppure [disabilitare gli aggiornamenti automatici](#disable-auto-updates) completamente. Le installazioni Homebrew, WinGet e [gestori di pacchetti Linux](#install-with-linux-package-managers) richiedono aggiornamenti manuali per impostazione predefinita.

179 179

180### Aggiornamenti automatici180### Aggiornamenti automatici

181 181

182Claude Code verifica la disponibilità di aggiornamenti all'avvio e periodicamente durante l'esecuzione. Gli aggiornamenti si scaricano e si installano in background, quindi hanno effetto la prossima volta che avviate Claude Code.182Claude Code verifica la disponibilità di aggiornamenti all'avvio e periodicamente durante l'esecuzione. Gli aggiornamenti si scaricano e si installano in background, quindi hanno effetto la prossima volta che avviate Claude Code.

183 183

184<Note>184<Note>

185 Le installazioni Homebrew, WinGet, apt, dnf e apk non si aggiornano automaticamente. Per Homebrew, eseguite `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask avete installato. Per WinGet, eseguite `winget upgrade Anthropic.ClaudeCode`. Per i gestori di pacchetti Linux, consultate i comandi di aggiornamento in [Installare con gestori di pacchetti Linux](#install-with-linux-package-managers).185 Le installazioni Homebrew, WinGet, apt, dnf e apk non si aggiornano automaticamente per impostazione predefinita; consultate di seguito per attivare l'opzione per Homebrew e WinGet. Per aggiornare Homebrew manualmente, eseguite `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask avete installato. Per WinGet, eseguite `winget upgrade Anthropic.ClaudeCode`. Per i gestori di pacchetti Linux, consultate i comandi di aggiornamento in [Installare con gestori di pacchetti Linux](#install-with-linux-package-managers).

186

187 Per fare in modo che Claude Code esegua il comando di aggiornamento per voi su Homebrew o WinGet, impostate [`CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE`](/it/env-vars) a `1`. Claude Code esegue quindi l'aggiornamento in background quando una nuova versione è disponibile e mostra un prompt di riavvio al completamento. L'aggiornamento riguarda solo il pacchetto Claude Code e non influisce su altro software che avete installato.

188

189 Su WinGet l'aggiornamento potrebbe non riuscire mentre Claude Code è in esecuzione perché Windows blocca l'eseguibile. In questo caso Claude Code mostra il comando manuale. apt, dnf e apk continuano a richiedere un aggiornamento manuale perché questi comandi necessitano di privilegi elevati.

186 190

187 **Problema noto:** Claude Code potrebbe notificarvi gli aggiornamenti prima che la nuova versione sia disponibile in questi gestori di pacchetti. Se un aggiornamento non riesce, attendete e riprovate più tardi.191 **Problema noto:** Claude Code potrebbe notificarvi gli aggiornamenti prima che la nuova versione sia disponibile in questi gestori di pacchetti. Se un aggiornamento non riesce, attendete e riprovate più tardi.

188 192

489 493

490## Disinstallare Claude Code494## Disinstallare Claude Code

491 495

492Per rimuovere Claude Code, seguite le istruzioni per il vostro metodo di installazione.496Per rimuovere Claude Code, seguite le istruzioni per il vostro metodo di installazione. Se `claude` continua a funzionare in seguito, probabilmente avete una seconda installazione o un alias shell residuo da un programma di installazione più vecchio. Consultate [Verificare le installazioni in conflitto](/it/troubleshoot-install#check-for-conflicting-installations) per trovarla e rimuoverla.

493 497

494### Installazione nativa498### Installazione nativa

495 499

skills.md +59 −26

Details

20 20

21## Skills raggruppate21## Skills raggruppate

22 22

23Claude Code include un set di skills raggruppate che sono disponibili in ogni sessione, incluse `/simplify`, `/batch`, `/debug`, `/loop`, e `/claude-api`. A differenza della maggior parte dei comandi integrati, che eseguono logica fissa direttamente, le skills raggruppate sono basate su prompt: danno a Claude un playbook dettagliato e gli permettono di orchestrare il lavoro utilizzando i suoi strumenti. Le invochi allo stesso modo di qualsiasi altra skill, digitando `/` seguito dal nome della skill.23Claude Code include un set di skills raggruppate che sono disponibili in ogni sessione, incluse `/simplify`, `/batch`, `/debug`, `/loop`, e `/claude-api`. A differenza della maggior parte dei comandi integrati, che eseguono logica fissa direttamente, le skills raggruppate sono basate su prompt: danno a Claude istruzioni dettagliate e gli permettono di orchestrare il lavoro utilizzando i suoi strumenti. Le invochi allo stesso modo di qualsiasi altra skill, digitando `/` seguito dal nome della skill.

24 24

25Le skills raggruppate sono elencate insieme ai comandi integrati nel [riferimento dei comandi](/it/commands), contrassegnate come **Skill** nella colonna Scopo.25Le skills raggruppate sono elencate insieme ai comandi integrati nel [riferimento dei comandi](/it/commands), contrassegnate come **Skill** nella colonna Scopo.

26 26

28 28

29### Crea la tua prima skill29### Crea la tua prima skill

30 30

31Questo esempio crea una skill che insegna a Claude di spiegare il codice usando diagrammi visivi e analogie. Poiché utilizza frontmatter predefinito, Claude può caricarla automaticamente quando chiedi come funziona qualcosa, oppure puoi invocarla direttamente con `/explain-code`.31Questo esempio crea una skill che riassume i cambiamenti non committati nel tuo repository git e segnala qualsiasi cosa rischiosa. Estrae il diff live nel prompt prima che Claude lo legga, quindi la risposta è basata sul tuo albero di lavoro effettivo piuttosto che su quello che Claude può indovinare dai file aperti. Claude carica la skill automaticamente quando chiedi dei tuoi cambiamenti, oppure puoi invocarla direttamente con `/summarize-changes`.

32 32

33<Steps>33<Steps>

34 <Step title="Crea la directory della skill">34 <Step title="Crea la directory della skill">

35 Crea una directory per la skill nella tua cartella di skills personali. Le skills personali sono disponibili su tutti i tuoi progetti.35 Crea una directory per la skill nella tua cartella di skills personali. Le skills personali sono disponibili su tutti i tuoi progetti.

36 36

37 ```bash theme={null}37 ```bash theme={null}

~~38 mkdir -p ~/.claude/skills/explain-code~~38 mkdir -p ~/.claude/skills/summarize-changes

39 ```39 ```

40 </Step>40 </Step>

41 41

42 <Step title="Scrivi SKILL.md">42 <Step title="Scrivi SKILL.md">

43 Ogni skill ha bisogno di un file `SKILL.md` con due parti: frontmatter YAML (tra i marcatori `---`) che dice a Claude quando usare la skill, e contenuto markdown con istruzioni che Claude segue quando la skill viene invocata. Il nome della directory diventa il `/slash-command`, e la `description` aiuta Claude a decidere quando caricarla automaticamente.43 Ogni skill ha bisogno di un file `SKILL.md` con due parti: frontmatter YAML tra i marcatori `---` che dice a Claude quando usare la skill, e contenuto markdown con le istruzioni che Claude segue quando la skill viene eseguita. Il nome della directory diventa il comando che digiti, e la `description` aiuta Claude a decidere quando caricare la skill automaticamente.

44 44

~~45 Crea `~/.claude/skills/explain-code/SKILL.md`:~~45 Salva questo in `~/.claude/skills/summarize-changes/SKILL.md`:

46 46

47 ```yaml theme={null}47 ```yaml theme={null}

48 ---48 ---

~~49 description: Explains code with visual diagrams and analogies. Use when explaining how code works, teaching about a codebase, or when the user asks "how does this work?"~~49 description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.

50 ---50 ---

51 51

~~52 When explaining code, always include:~~52 ## Current changes

53 53

~~54 1. **Start with an analogy**: Compare the code to something from everyday life~~54 !`git diff HEAD`

~~55 2. **Draw a diagram**: Use ASCII art to show the flow, structure, or relationships~~

~~56 3. **Walk through the code**: Explain step-by-step what happens~~

~~57 4. **Highlight a gotcha**: What's a common mistake or misconception?~~

58 55

~~59 Keep explanations conversational. For complex concepts, use multiple analogies.~~56 ## Instructions

58 Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

60 ```59 ```

61 La riga `` !`git diff HEAD` `` utilizza [iniezione di contesto dinamico](#inject-dynamic-context): Claude Code esegue il comando e sostituisce la riga con il suo output prima che Claude veda il contenuto della skill, quindi le istruzioni arrivano con il diff attuale già inline.

61 </Step>62 </Step>

62 63

63 <Step title="Testa la skill">64 <Step title="Testa la skill">

~~64 Puoi testarla in due modi:~~65 Apri un progetto git, fai una piccola modifica a qualsiasi file, e avvia Claude Code eseguendo `claude`. Puoi testare la skill in due modi.

65 66

66 **Lascia che Claude la invochi automaticamente** chiedendo qualcosa che corrisponda alla descrizione:67 **Lascia che Claude la invochi automaticamente** chiedendo qualcosa che corrisponda alla descrizione:

67 68

68 ```text theme={null}69 ```text theme={null}

~~69 How does this code work?~~70 What did I change?

70 ```71 ```

71 72

72 **O invocarla direttamente** con il nome della skill:73 **O invocarla direttamente** con il nome della skill:

73 74

74 ```text theme={null}75 ```text theme={null}

~~75 /explain-code src/auth/login.ts~~76 /summarize-changes

76 ```77 ```

77 78

~~78 In entrambi i casi, Claude dovrebbe includere un'analogia e un diagramma ASCII nella sua spiegazione.~~79 In entrambi i casi, Claude dovrebbe rispondere con un breve riassunto della tua modifica e un elenco di rischi.

79 </Step>80 </Step>

80</Steps>81</Steps>

81 82

168 169

169Il tuo `SKILL.md` può contenere qualsiasi cosa, ma pensare a come vuoi che la skill venga invocata (da te, da Claude, o da entrambi) e dove vuoi che venga eseguita (inline o in un subagent) aiuta a guidare cosa includere. Per skills complesse, puoi anche [aggiungere file di supporto](#add-supporting-files) per mantenere la skill principale focalizzata.170Il tuo `SKILL.md` può contenere qualsiasi cosa, ma pensare a come vuoi che la skill venga invocata (da te, da Claude, o da entrambi) e dove vuoi che venga eseguita (inline o in un subagent) aiuta a guidare cosa includere. Per skills complesse, puoi anche [aggiungere file di supporto](#add-supporting-files) per mantenere la skill principale focalizzata.

170 171

172Mantieni il corpo stesso conciso. Una volta che una skill si carica, il suo contenuto [rimane nel contesto tra i turni](#skill-content-lifecycle), quindi ogni riga è un costo di token ricorrente. Dichiara cosa fare piuttosto che narrare come o perché, e applica lo stesso test di concisione che faresti per il [contenuto di CLAUDE.md](/it/best-practices#write-an-effective-claude-md).

173

171### Riferimento del frontmatter174### Riferimento del frontmatter

172 175

173Oltre al contenuto markdown, puoi configurare il comportamento della skill utilizzando campi frontmatter YAML tra i marcatori `---` in cima al tuo file `SKILL.md`:176Oltre al contenuto markdown, puoi configurare il comportamento della skill utilizzando campi frontmatter YAML tra i marcatori `---` in cima al tuo file `SKILL.md`:

305 308

306Il campo `allowed-tools` concede il permesso per gli strumenti elencati mentre la skill è attiva, in modo che Claude possa usarli senza chiederti l'approvazione per ogni uso. Non limita quali strumenti sono disponibili: ogni strumento rimane richiamabile, e le tue [impostazioni di permesso](/it/permissions) governano comunque gli strumenti che non sono elencati.309Il campo `allowed-tools` concede il permesso per gli strumenti elencati mentre la skill è attiva, in modo che Claude possa usarli senza chiederti l'approvazione per ogni uso. Non limita quali strumenti sono disponibili: ogni strumento rimane richiamabile, e le tue [impostazioni di permesso](/it/permissions) governano comunque gli strumenti che non sono elencati.

307 310

311Per le skills controllate in una directory `.claude/skills/` di un progetto, `allowed-tools` ha effetto dopo che accetti la finestra di dialogo di trust dell'area di lavoro per quella cartella, come le regole di permesso in `.claude/settings.json`. Rivedi le skills del progetto prima di fidarti di un repository, poiché una skill può concedere a se stessa un ampio accesso agli strumenti.

312

308Questa skill permette a Claude di eseguire comandi git senza approvazione per uso ogni volta che la invochi:313Questa skill permette a Claude di eseguire comandi git senza approvazione per uso ogni volta che la invochi:

309 314

310```yaml theme={null}315```yaml theme={null}

416Per disabilitare questo comportamento per skills e comandi personalizzati da fonti utente, progetto, plugin, o [directory aggiuntiva](#skills-from-additional-directories), imposta `"disableSkillShellExecution": true` nelle [impostazioni](/it/settings). Ogni comando viene sostituito con `[shell command execution disabled by policy]` invece di essere eseguito. Le skills raggruppate e gestite non sono interessate. Questa impostazione è più utile nelle [impostazioni gestite](/it/permissions#managed-settings), dove gli utenti non possono sovrascriverla.421Per disabilitare questo comportamento per skills e comandi personalizzati da fonti utente, progetto, plugin, o [directory aggiuntiva](#skills-from-additional-directories), imposta `"disableSkillShellExecution": true` nelle [impostazioni](/it/settings). Ogni comando viene sostituito con `[shell command execution disabled by policy]` invece di essere eseguito. Le skills raggruppate e gestite non sono interessate. Questa impostazione è più utile nelle [impostazioni gestite](/it/permissions#managed-settings), dove gli utenti non possono sovrascriverla.

417 422

418<Tip>423<Tip>

419 Per abilitare il [pensiero esteso](/it/common-workflows#use-extended-thinking-thinking-mode) in una skill, includi la parola "ultrathink" da qualche parte nel contenuto della tua skill.424 Per richiedere un ragionamento più profondo quando una skill viene eseguita, includi `ultrathink` da qualche parte nel contenuto della skill. Vedi [Usa ultrathink per il ragionamento profondo una tantum](/it/model-config#use-ultrathink-for-one-off-deep-reasoning).

420</Tip>425</Tip>

421 426

422### Esegui skills in un subagent427### Esegui skills in un subagent

496 Il campo `user-invocable` controlla solo la visibilità del menu, non l'accesso allo strumento Skill. Usa `disable-model-invocation: true` per bloccare l'invocazione programmatica.501 Il campo `user-invocable` controlla solo la visibilità del menu, non l'accesso allo strumento Skill. Usa `disable-model-invocation: true` per bloccare l'invocazione programmatica.

497</Note>502</Note>

498 503

504### Sovrascrivi la visibilità della skill dalle impostazioni

505

506L'impostazione `skillOverrides` controlla la visibilità della skill dalle tue [impostazioni](/it/settings) invece del frontmatter della skill stessa. Usala per skills il cui SKILL.md non vuoi modificare, come quelle controllate in un repository di progetto condiviso o fornite da un server MCP. Il menu `/skills` lo scrive per te: evidenzia una skill e premi `Space` per ciclo gli stati, quindi `Enter` per salvare in `.claude/settings.local.json`.

507

508Ogni chiave è un nome di skill e ogni valore è uno di quattro stati:

509

510| Valore | Elencato a Claude | Nel menu `/` |

511| :---------------------- | :----------------- | :----------- |

512| `"on"` | Nome e descrizione | Sì |

513| `"name-only"` | Solo nome | Sì |

514| `"user-invocable-only"` | Nascosto | Sì |

515| `"off"` | Nascosto | Nascosto |

516

517Una skill assente da `skillOverrides` è trattata come `"on"`. L'esempio seguente comprime una skill al suo nome e disattiva completamente un'altra:

518

519```json theme={null}

520{

521 "skillOverrides": {

522 "legacy-context": "name-only",

523 "deploy": "off"

524 }

525}

526```

527

528Le skills dei plugin non sono interessate da `skillOverrides`. Gestisci quelle tramite `/plugin` invece.

529

499## Condividi skills530## Condividi skills

500 531

501Le skills possono essere distribuite a diversi ambiti a seconda del tuo pubblico:532Le skills possono essere distribuite a diversi ambiti a seconda del tuo pubblico:

516mkdir -p ~/.claude/skills/codebase-visualizer/scripts547mkdir -p ~/.claude/skills/codebase-visualizer/scripts

517```548```

518 549

519Crea `~/.claude/skills/codebase-visualizer/SKILL.md`. La descrizione dice a Claude quando attivare questa Skill, e le istruzioni dicono a Claude di eseguire lo script raggruppato:550Salva questo in `~/.claude/skills/codebase-visualizer/SKILL.md`. La descrizione dice a Claude quando attivare questa Skill, e le istruzioni dicono a Claude di eseguire lo script raggruppato. Il percorso dello script utilizza [`${CLAUDE_SKILL_DIR}`](#available-string-substitutions) in modo che si risolva correttamente indipendentemente dal fatto che la skill sia installata a livello personale, di progetto o di plugin:

520 551

521````yaml theme={null}552````yaml theme={null}

522---553---

523name: codebase-visualizer554name: codebase-visualizer

524description: Generate an interactive collapsible tree visualization of your codebase. Use when exploring a new repo, understanding project structure, or identifying large files.555description: Generate an interactive collapsible tree visualization of your codebase. Use when exploring a new repo, understanding project structure, or identifying large files.

525allowed-tools: Bash(python *)556allowed-tools: Bash(python3 *)

526---557---

527 558

528# Codebase Visualizer559# Codebase Visualizer

534Run the visualization script from your project root:565Run the visualization script from your project root:

535 566

536```bash567```bash

537python ~/.claude/skills/codebase-visualizer/scripts/visualize.py .568python3 ${CLAUDE_SKILL_DIR}/scripts/visualize.py .

538```569```

539 570

540This creates `codebase-map.html` in the current directory and opens it in your default browser.571This creates `codebase-map.html` in the current directory and opens it in your default browser.

547- **Directory totals**: Shows aggregate size of each folder578- **Directory totals**: Shows aggregate size of each folder

548````579````

549 580

550Crea `~/.claude/skills/codebase-visualizer/scripts/visualize.py`. Questo script scansiona un albero di directory e genera un file HTML autonomo con:581Salva questo in `~/.claude/skills/codebase-visualizer/scripts/visualize.py`. Questo script scansiona un albero di directory e genera un file HTML autonomo con:

551 582

552* Una **barra laterale di riepilogo** che mostra il conteggio dei file, il conteggio delle directory, la dimensione totale e il numero di tipi di file583* Una **barra laterale di riepilogo** che mostra il conteggio dei file, il conteggio delle directory, la dimensione totale e il numero di tipi di file

553* Un **grafico a barre** che suddivide il codebase per tipo di file (i primi 8 per dimensione)584* Un **grafico a barre** che suddivide il codebase per tipo di file (i primi 8 per dimensione)

554* Un **albero comprimibile** dove puoi espandere e comprimere directory, con indicatori di tipo di file codificati per colore585* Un **albero comprimibile** dove puoi espandere e comprimere directory, con indicatori di tipo di file codificati per colore

555 586

556Lo script richiede Python ma utilizza solo librerie integrate, quindi non ci sono pacchetti da installare:587Lo script richiede Python 3 ma utilizza solo librerie integrate, quindi non ci sono pacchetti da installare:

557 588

558```python expandable theme={null}589```python expandable theme={null}

559#!/usr/bin/env python3590#!/usr/bin/env python3

562import json593import json

563import sys594import sys

564import webbrowser595import webbrowser

596from html import escape

565from pathlib import Path597from pathlib import Path

566from collections import Counter598from collections import Counter

567 599

650 {lang_bars}682 {lang_bars}

651 </div>683 </div>

652 <div class="main">684 <div class="main">

653 <h1>📁 {data["name"]}</h1>685 <h1>📁 {escape(data["name"])}</h1>

654 <ul class="tree" id="root"></ul>686 <ul class="tree" id="root"></ul>

655 </div>687 </div>

656 </div>688 </div>

658 const data = {json.dumps(data)};690 const data = {json.dumps(data)};

659 const colors = {json.dumps(colors)};691 const colors = {json.dumps(colors)};

660 function fmt(b) {{ if (b < 1024) return b + ' B'; if (b < 1048576) return (b/1024).toFixed(1) + ' KB'; return (b/1048576).toFixed(1) + ' MB'; }}692 function fmt(b) {{ if (b < 1024) return b + ' B'; if (b < 1048576) return (b/1024).toFixed(1) + ' KB'; return (b/1048576).toFixed(1) + ' MB'; }}

693 function esc(s) {{ return s.replace(/[&<>"']/g, c => ({{"&":"&","<":"<",">":">",'"':""","'":"'"}}[c])); }}

661 function render(node, parent) {{694 function render(node, parent) {{

662 if (node.children) {{695 if (node.children) {{

663 const det = document.createElement('details');696 const det = document.createElement('details');

664 det.open = parent === document.getElementById('root');697 det.open = parent === document.getElementById('root');

665 det.innerHTML = `<summary><span class="folder">📁 ${{node.name}}</span><span class="size">${{fmt(node.size)}}</span></summary>`;698 det.innerHTML = `<summary><span class="folder">📁 ${{esc(node.name)}}</span><span class="size">${{fmt(node.size)}}</span></summary>`;

666 const ul = document.createElement('ul'); ul.className = 'tree';699 const ul = document.createElement('ul'); ul.className = 'tree';

667 node.children.sort((a,b) => (b.children?1:0)-(a.children?1:0) || a.name.localeCompare(b.name));700 node.children.sort((a,b) => (b.children?1:0)-(a.children?1:0) || a.name.localeCompare(b.name));

668 node.children.forEach(c => render(c, ul));701 node.children.forEach(c => render(c, ul));

670 const li = document.createElement('li'); li.appendChild(det); parent.appendChild(li);703 const li = document.createElement('li'); li.appendChild(det); parent.appendChild(li);

671 }} else {{704 }} else {{

672 const li = document.createElement('li'); li.className = 'file';705 const li = document.createElement('li'); li.className = 'file';

673 li.innerHTML = `<span class="dot" style="background:${{colors[node.ext]||'#6b7280'}}"></span>${{node.name}}<span class="size">${{fmt(node.size)}}</span>`;706 li.innerHTML = `<span class="dot" style="background:${{colors[node.ext]||'#6b7280'}}"></span>${{esc(node.name)}}<span class="size">${{fmt(node.size)}}</span>`;

674 parent.appendChild(li);707 parent.appendChild(li);

675 }}708 }}

676 }}709 }}

715 748

716Le descrizioni delle skills vengono caricate nel contesto in modo che Claude sappia cosa è disponibile. Tutti i nomi delle skills sono sempre inclusi, ma se hai molte skills, le descrizioni vengono accorciate per adattarsi al budget dei caratteri, il che può rimuovere le parole chiave di cui Claude ha bisogno per corrispondere alla tua richiesta. Il budget si ridimensiona dinamicamente all'1% della finestra di contesto, con un fallback di 8.000 caratteri.749Le descrizioni delle skills vengono caricate nel contesto in modo che Claude sappia cosa è disponibile. Tutti i nomi delle skills sono sempre inclusi, ma se hai molte skills, le descrizioni vengono accorciate per adattarsi al budget dei caratteri, il che può rimuovere le parole chiave di cui Claude ha bisogno per corrispondere alla tua richiesta. Il budget si ridimensiona dinamicamente all'1% della finestra di contesto, con un fallback di 8.000 caratteri.

717 750

718Per aumentare il limite, imposta la variabile di ambiente `SLASH_COMMAND_TOOL_CHAR_BUDGET`. Oppure taglia le descrizioni alla fonte: metti in primo piano il caso d'uso chiave, poiché il testo combinato di `description` e `when_to_use` di ogni voce è limitato a 1.536 caratteri indipendentemente dal budget.751Per aumentare il limite, imposta la variabile di ambiente `SLASH_COMMAND_TOOL_CHAR_BUDGET`. Per liberare budget per altre skills, imposta le voci a bassa priorità su `"name-only"` in [`skillOverrides`](#override-skill-visibility-from-settings) in modo che si elenchino senza una descrizione. Puoi anche ridurre il testo di `description` e `when_to_use` alla fonte: metti in primo piano il caso d'uso chiave, poiché il testo combinato di ogni voce è limitato a 1.536 caratteri indipendentemente dal budget.

719 752

720## Risorse correlate753## Risorse correlate

721 754

statusline.md +10 −11

Details

134 134

135**Quando si aggiorna**135**Quando si aggiorna**

136 136

137Il tuo script viene eseguito dopo ogni nuovo messaggio dell'assistente, quando cambia la modalità di autorizzazione o quando la modalità vim si attiva/disattiva. Gli aggiornamenti vengono debounced a 300ms, il che significa che i cambiamenti rapidi si raggruppano insieme e il tuo script viene eseguito una volta che le cose si stabilizzano. Se un nuovo aggiornamento si attiva mentre il tuo script è ancora in esecuzione, l'esecuzione in corso viene annullata. Se modifichi il tuo script, le modifiche non appariranno fino al prossimo aggiornamento di Claude Code.137Il tuo script viene eseguito dopo ogni nuovo messaggio dell'assistente, dopo che `/compact` termina, quando cambia la modalità di autorizzazione o quando la modalità vim si attiva/disattiva. Gli aggiornamenti vengono debounced a 300ms, il che significa che i cambiamenti rapidi si raggruppano insieme e il tuo script viene eseguito una volta che le cose si stabilizzano. Se un nuovo aggiornamento si attiva mentre il tuo script è ancora in esecuzione, l'esecuzione in corso viene annullata. Se modifichi il tuo script, le modifiche non appariranno fino al prossimo aggiornamento di Claude Code.

138 138

139Questi trigger possono diventare silenziosi quando la sessione principale è inattiva, ad esempio mentre un coordinatore attende i subagent in background. Per mantenere i segmenti basati sul tempo o provenienti da fonti esterne aggiornati durante i periodi di inattività, imposta [`refreshInterval`](#manually-configure-a-status-line) per eseguire nuovamente il comando anche su un timer fisso.139Questi trigger possono diventare silenziosi quando la sessione principale è inattiva, ad esempio mentre un coordinatore attende i subagent in background. Per mantenere i segmenti basati sul tempo o provenienti da fonti esterne aggiornati durante i periodi di inattività, imposta [`refreshInterval`](#manually-configure-a-status-line) per eseguire nuovamente il comando anche su un timer fisso.

140 140

164| `context_window.total_input_tokens`, `context_window.total_output_tokens` | Conteggi cumulativi dei token nella sessione |164| `context_window.total_input_tokens`, `context_window.total_output_tokens` | Conteggi dei token attualmente nella finestra di contesto, dalla risposta API più recente. L'input include letture e scritture della cache. Prima della v2.1.132 questi erano totali cumulativi della sessione |

165| `context_window.context_window_size` | Dimensione massima della finestra di contesto in token. 200000 per impostazione predefinita, o 1000000 per i modelli con contesto esteso. |165| `context_window.context_window_size` | Dimensione massima della finestra di contesto in token. 200000 per impostazione predefinita, o 1000000 per i modelli con contesto esteso. |

215 "total_lines_removed": 23215 "total_lines_removed": 23

216 },216 },

217 "context_window": {217 "context_window": {

218 "total_input_tokens": 15234,218 "total_input_tokens": 15500,

219 "total_output_tokens": 4521,219 "total_output_tokens": 1200,

220 "context_window_size": 200000,220 "context_window_size": 200000,

221 "used_percentage": 8,221 "used_percentage": 8,

222 "remaining_percentage": 92,222 "remaining_percentage": 92,

272 272

273 **Campi che potrebbero essere `null`**:273 **Campi che potrebbero essere `null`**:

274 274

275 * `context_window.current_usage`: `null` prima della prima chiamata API in una sessione275 * `context_window.current_usage`: `null` prima della prima chiamata API in una sessione, e di nuovo dopo `/compact` fino a quando la prossima chiamata API non lo ripopola

276 * `context_window.used_percentage`, `context_window.remaining_percentage`: potrebbero essere `null` all'inizio della sessione276 * `context_window.used_percentage`, `context_window.remaining_percentage`: potrebbero essere `null` all'inizio della sessione

277 277

278 Gestisci i campi mancanti con accesso condizionale e i valori null con fallback predefiniti nei tuoi script.278 Gestisci i campi mancanti con accesso condizionale e i valori null con fallback predefiniti nei tuoi script.

280 280

281### Campi della finestra di contesto281### Campi della finestra di contesto

282 282

283L'oggetto `context_window` fornisce due modi per tracciare l'utilizzo del contesto:283L'oggetto `context_window` descrive la finestra di contesto attiva dalla risposta API più recente. A partire dalla v2.1.132, `total_input_tokens` e `total_output_tokens` riflettono l'utilizzo del contesto corrente, non i totali cumulativi della sessione.

284 284

285* **Totali cumulativi** (`total_input_tokens`, `total_output_tokens`): somma di tutti i token nell'intera sessione, utile per tracciare il consumo totale285* **Totali combinati** (`total_input_tokens`, `total_output_tokens`): token attualmente nella finestra di contesto. `total_input_tokens` è la somma di `input_tokens`, `cache_creation_input_tokens` e `cache_read_input_tokens`; `total_output_tokens` sono i token di output dalla risposta più recente. Entrambi sono `0` prima della prima risposta API.

286* **Utilizzo corrente** (`current_usage`): conteggi dei token dall'ultima chiamata API, usa questo per una percentuale di contesto accurata poiché riflette lo stato effettivo del contesto286* **Utilizzo per componente** (`current_usage`): gli stessi conteggi dei token suddivisi per categoria. Usa questo quando hai bisogno di separare i cache hit dall'input fresco.

287 287

288L'oggetto `current_usage` contiene:288L'oggetto `current_usage` contiene:

289 289

296 296

297Se calcoli manualmente la percentuale di contesto da `current_usage`, usa la stessa formula solo per l'input per corrispondere a `used_percentage`.297Se calcoli manualmente la percentuale di contesto da `current_usage`, usa la stessa formula solo per l'input per corrispondere a `used_percentage`.

298 298

299L'oggetto `current_usage` è `null` prima della prima chiamata API in una sessione.299L'oggetto `current_usage` è `null` prima della prima chiamata API in una sessione, e di nuovo immediatamente dopo `/compact` fino a quando la prossima chiamata API non lo ripopola.

300 300

301## Esempi301## Esempi

302 302

1011 1011

1012**La percentuale di contesto mostra valori inaspettati**1012**La percentuale di contesto mostra valori inaspettati**

1013 1013

1014* Usa `used_percentage` per uno stato di contesto accurato piuttosto che i totali cumulativi1014* Usa `used_percentage` per lo stato di contesto più semplice e accurato

1015* `total_input_tokens` e `total_output_tokens` sono cumulativi nella sessione e potrebbero superare la dimensione della finestra di contesto

1016* La percentuale di contesto potrebbe differire dall'output `/context` a causa di quando ciascuno viene calcolato1015* La percentuale di contesto potrebbe differire dall'output `/context` a causa di quando ciascuno viene calcolato

1017 1016

1018**I link OSC 8 non sono cliccabili**1017**I link OSC 8 non sono cliccabili**

terminal-config.md +3 −3

Details

24Nella maggior parte dei terminali puoi anche premere Shift+Invio, ma il supporto varia a seconda dell'emulatore di terminale:24Nella maggior parte dei terminali puoi anche premere Shift+Invio, ma il supporto varia a seconda dell'emulatore di terminale:

25 25

26| Terminale | Shift+Invio per nuova riga |26| Terminale | Shift+Invio per nuova riga |

~~27| :----------------------------------------------------------------------------- | :------------------------------------------ |~~27| :---------------------------------------------------------------------- | :------------------------------------------ |

~~28| Ghostty, Kitty, iTerm2, WezTerm, Warp, Apple Terminal | Funziona senza configurazione |~~28| Ghostty, Kitty, iTerm2, WezTerm, Warp, Apple Terminal, Windows Terminal | Funziona senza configurazione |

29| VS Code, Cursor, Windsurf, Alacritty, Zed | Esegui `/terminal-setup` una volta |29| VS Code, Cursor, Windsurf, Alacritty, Zed | Esegui `/terminal-setup` una volta |

31 31

32Per VS Code, Cursor, Windsurf, Alacritty e Zed, `/terminal-setup` scrive Shift+Invio e altre scorciatoie da tastiera nel file di configurazione del terminale. In VS Code, Cursor e Windsurf imposta anche `terminal.integrated.mouseWheelScrollSensitivity` nelle impostazioni dell'editor per uno scorrimento più fluido in [modalità a schermo intero](/it/fullscreen). I binding e le impostazioni esistenti rimangono in posizione; se vedi un messaggio come `VSCode terminal Shift+Enter key binding already configured`, non è stata apportata alcuna modifica. Esegui `/terminal-setup` direttamente nel terminale host piuttosto che dentro tmux o screen, poiché ha bisogno di scrivere nella configurazione del terminale host.32Per VS Code, Cursor, Windsurf, Alacritty e Zed, `/terminal-setup` scrive Shift+Invio e altre scorciatoie da tastiera nel file di configurazione del terminale. In VS Code, Cursor e Windsurf imposta anche `terminal.integrated.mouseWheelScrollSensitivity` nelle impostazioni dell'editor per uno scorrimento più fluido in [modalità a schermo intero](/it/fullscreen). I binding e le impostazioni esistenti rimangono in posizione; se vedi un messaggio come `VSCode terminal Shift+Enter key binding already configured`, non è stata apportata alcuna modifica. Esegui `/terminal-setup` direttamente nel terminale host piuttosto che dentro tmux o screen, poiché ha bisogno di scrivere nella configurazione del terminale host.

33 33

Documentation 2026-05-05 23:00 UTC to 2026-05-07 22:59 UTC