Documentation — Spybara

admin-setup.md +1 −0

Details

74| [MCP server control](/it/mcp#managed-mcp-configuration) | Limitare quali server MCP gli utenti possono aggiungere o connettere | `allowedMcpServers`, `deniedMcpServers`, `allowManagedMcpServersOnly` |74| [MCP server control](/it/mcp#managed-mcp-configuration) | Limitare quali server MCP gli utenti possono aggiungere o connettere | `allowedMcpServers`, `deniedMcpServers`, `allowManagedMcpServersOnly` |

75| [Plugin marketplace control](/it/plugin-marketplaces#managed-marketplace-restrictions) | Limitare quali fonti di marketplace gli utenti possono aggiungere e installare | `strictKnownMarketplaces`, `blockedMarketplaces` |75| [Plugin marketplace control](/it/plugin-marketplaces#managed-marketplace-restrictions) | Limitare quali fonti di marketplace gli utenti possono aggiungere e installare | `strictKnownMarketplaces`, `blockedMarketplaces` |

76| [Hook restrictions](/it/settings#hook-configuration) | Solo gli hook gestiti vengono caricati; limitare gli URL degli hook HTTP | `allowManagedHooksOnly`, `allowedHttpHookUrls` |76| [Hook restrictions](/it/settings#hook-configuration) | Solo gli hook gestiti vengono caricati; limitare gli URL degli hook HTTP | `allowManagedHooksOnly`, `allowedHttpHookUrls` |

77| [Disable agent view](/it/agent-view#how-background-sessions-are-hosted) | Disattivare `claude agents`, `--bg`, `/background` e il supervisore on-demand | `disableAgentView` |

78 79

79Le regole di autorizzazione e il sandboxing coprono livelli diversi. Negare WebFetch blocca lo strumento fetch di Claude, ma se Bash è consentito, `curl` e `wget` possono comunque raggiungere qualsiasi URL. Il sandboxing chiude questo divario con un allowlist di domini di rete applicato a livello di sistema operativo.80Le regole di autorizzazione e il sandboxing coprono livelli diversi. Negare WebFetch blocca lo strumento fetch di Claude, ma se Bash è consentito, `curl` e `wget` possono comunque raggiungere qualsiasi URL. Il sandboxing chiude questo divario con un allowlist di domini di rete applicato a livello di sistema operativo.

agent-sdk/overview.md +2 −1

Details

90 L'SDK supporta anche l'autenticazione tramite provider API di terze parti:90 L'SDK supporta anche l'autenticazione tramite provider API di terze parti:

91 91

92 * **Amazon Bedrock**: imposta la variabile di ambiente `CLAUDE_CODE_USE_BEDROCK=1` e configura le credenziali AWS92 * **Amazon Bedrock**: imposta la variabile di ambiente `CLAUDE_CODE_USE_BEDROCK=1` e configura le credenziali AWS

93 * **Claude Platform on AWS**: imposta `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` e `ANTHROPIC_AWS_WORKSPACE_ID`, quindi configura le credenziali AWS

93 * **Google Vertex AI**: imposta la variabile di ambiente `CLAUDE_CODE_USE_VERTEX=1` e configura le credenziali di Google Cloud94 * **Google Vertex AI**: imposta la variabile di ambiente `CLAUDE_CODE_USE_VERTEX=1` e configura le credenziali di Google Cloud

94 * **Microsoft Azure**: imposta la variabile di ambiente `CLAUDE_CODE_USE_FOUNDRY=1` e configura le credenziali di Azure95 * **Microsoft Azure**: imposta la variabile di ambiente `CLAUDE_CODE_USE_FOUNDRY=1` e configura le credenziali di Azure

95 96

~~96 Consulta le guide di configurazione per [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai) o [Azure AI Foundry](/it/microsoft-foundry) per i dettagli.~~97 Consulta le guide di configurazione per [Bedrock](/it/amazon-bedrock), [Claude Platform on AWS](/it/claude-platform-on-aws), [Vertex AI](/it/google-vertex-ai) o [Azure AI Foundry](/it/microsoft-foundry) per i dettagli.

97 98

98 <Note>99 <Note>

99 Se non precedentemente approvato, Anthropic non consente agli sviluppatori di terze parti di offrire l'accesso a claude.ai o limiti di velocità per i loro prodotti, inclusi gli agenti costruiti su Claude Agent SDK. Utilizza invece i metodi di autenticazione con chiave API descritti in questo documento.100 Se non precedentemente approvato, Anthropic non consente agli sviluppatori di terze parti di offrire l'accesso a claude.ai o limiti di velocità per i loro prodotti, inclusi gli agenti costruiti su Claude Agent SDK. Utilizza invece i metodi di autenticazione con chiave API descritti in questo documento.

agent-sdk/python.md +115 −113

Details

2294 2294

2295```python theme={null}2295```python theme={null}

2296{2296{

2297 "description": str, # A short (3-5 word) description of the task2297 "description": str, # Una breve descrizione del compito (3-5 parole)

2298 "prompt": str, # The task for the agent to perform2298 "prompt": str, # Il compito che l'agente deve eseguire

2299 "subagent_type": str, # The type of specialized agent to use2299 "subagent_type": str, # Il tipo di agente specializzato da utilizzare

2300}2300}

2301```2301```

2302 2302

2304 2304

2305```python theme={null}2305```python theme={null}

2306{2306{

2307 "result": str, # Final result from the subagent2307 "result": str, # Risultato finale dal subagente

2308 "usage": dict | None, # Token usage statistics2308 "usage": dict | None, # Statistiche di utilizzo dei token

2309 "total_cost_usd": float | None, # Estimated total cost in USD2309 "total_cost_usd": float | None, # Costo totale stimato in USD

2310 "duration_ms": int | None, # Execution duration in milliseconds2310 "duration_ms": int | None, # Durata dell'esecuzione in millisecondi

2311}2311}

2312```2312```

2313 2313

2321 2321

2322```python theme={null}2322```python theme={null}

2323{2323{

2324 "questions": [ # Questions to ask the user (1-4 questions)2324 "questions": [ # Domande da porre all'utente (1-4 domande)

2325 {2325 {

2326 "question": str, # The complete question to ask the user2326 "question": str, # La domanda completa da porre all'utente

2327 "header": str, # Very short label displayed as a chip/tag (max 12 chars)2327 "header": str, # Etichetta molto breve visualizzata come chip/tag (max 12 caratteri)

2328 "options": [ # The available choices (2-4 options)2328 "options": [ # Le scelte disponibili (2-4 opzioni)

2329 {2329 {

2330 "label": str, # Display text for this option (1-5 words)2330 "label": str, # Testo visualizzato per questa opzione (1-5 parole)

2331 "description": str, # Explanation of what this option means2331 "description": str, # Spiegazione di cosa significa questa opzione

2332 }2332 }

2333 ],2333 ],

2334 "multiSelect": bool, # Set to true to allow multiple selections2334 "multiSelect": bool, # Impostare su true per consentire selezioni multiple

2335 }2335 }

2336 ],2336 ],

2337 "answers": dict[str, str | list[str]] | None,2337 "answers": dict[str, str | list[str]] | None,

2338 # User answers populated by the permission system. Multi-select2338 # Risposte dell'utente popolate dal sistema di autorizzazione. Le risposte

2339 # answers may be a list of labels or a comma-joined string2339 # multi-select possono essere un elenco di etichette o una stringa unita da virgole

2340}2340}

2341```2341```

2342 2342

2344 2344

2345```python theme={null}2345```python theme={null}

2346{2346{

2347 "questions": [ # The questions that were asked2347 "questions": [ # Le domande che sono state poste

2348 {2348 {

2349 "question": str,2349 "question": str,

2350 "header": str,2350 "header": str,

2352 "multiSelect": bool,2352 "multiSelect": bool,

2353 }2353 }

2354 ],2354 ],

2355 "answers": dict[str, str], # Maps question text to answer string2355 "answers": dict[str, str], # Mappa il testo della domanda alla stringa di risposta

2356 # Multi-select answers are comma-separated2356 # Le risposte multi-select sono separate da virgole

2357}2357}

2358```2358```

2359 2359

2365 2365

2366```python theme={null}2366```python theme={null}

2367{2367{

2368 "command": str, # The command to execute2368 "command": str, # Il comando da eseguire

2369 "timeout": int | None, # Optional timeout in milliseconds (max 600000)2369 "timeout": int | None, # Timeout opzionale in millisecondi (max 600000)

2370 "description": str | None, # Clear, concise description (5-10 words)2370 "description": str | None, # Descrizione chiara e concisa (5-10 parole)

2371 "run_in_background": bool | None, # Set to true to run in background2371 "run_in_background": bool | None, # Impostare su true per eseguire in background

2372}2372}

2373```2373```

2374 2374

2376 2376

2377```python theme={null}2377```python theme={null}

2378{2378{

2379 "output": str, # Combined stdout and stderr output2379 "output": str, # Output combinato di stdout e stderr

2380 "exitCode": int, # Exit code of the command2380 "exitCode": int, # Codice di uscita del comando

2381 "killed": bool | None, # Whether command was killed due to timeout2381 "killed": bool | None, # Se il comando è stato terminato a causa del timeout

2382 "shellId": str | None, # Shell ID for background processes2382 "shellId": str | None, # ID della shell per i processi in background

2383}2383}

2384```2384```

2385 2385

2393 2393

2394```python theme={null}2394```python theme={null}

2395{2395{

2396 "command": str, # Shell script; each stdout line is an event, exit ends the watch2396 "command": str, # Script shell; ogni riga stdout è un evento, exit termina il monitoraggio

2397 "description": str, # Short description shown in notifications2397 "description": str, # Breve descrizione mostrata nelle notifiche

2398 "timeout_ms": int | None, # Kill after this deadline (default 300000, max 3600000)2398 "timeout_ms": int | None, # Termina dopo questa scadenza (default 300000, max 3600000)

2399 "persistent": bool | None, # Run for the lifetime of the session; stop with TaskStop2399 "persistent": bool | None, # Esegui per la durata della sessione; ferma con TaskStop

2400}2400}

2401```2401```

2402 2402

2404 2404

2405```python theme={null}2405```python theme={null}

2406{2406{

2407 "taskId": str, # ID of the background monitor task2407 "taskId": str, # ID dell'attività di monitoraggio in background

2408 "timeoutMs": int, # Timeout deadline in milliseconds (0 when persistent)2408 "timeoutMs": int, # Scadenza del timeout in millisecondi (0 quando persistente)

2409 "persistent": bool | None, # True when running until TaskStop or session end2409 "persistent": bool | None, # True quando in esecuzione fino a TaskStop o fine sessione

2410}2410}

2411```2411```

2412 2412

2418 2418

2419```python theme={null}2419```python theme={null}

2420{2420{

2421 "file_path": str, # The absolute path to the file to modify2421 "file_path": str, # Il percorso assoluto del file da modificare

2422 "old_string": str, # The text to replace2422 "old_string": str, # Il testo da sostituire

2423 "new_string": str, # The text to replace it with2423 "new_string": str, # Il testo con cui sostituirlo

2424 "replace_all": bool | None, # Replace all occurrences (default False)2424 "replace_all": bool | None, # Sostituisci tutte le occorrenze (default False)

2425}2425}

2426```2426```

2427 2427

2429 2429

2430```python theme={null}2430```python theme={null}

2431{2431{

2432 "message": str, # Confirmation message2432 "message": str, # Messaggio di conferma

2433 "replacements": int, # Number of replacements made2433 "replacements": int, # Numero di sostituzioni effettuate

2434 "file_path": str, # File path that was edited2434 "file_path": str, # Percorso del file che è stato modificato

2435}2435}

2436```2436```

2437 2437

2443 2443

2444```python theme={null}2444```python theme={null}

2445{2445{

2446 "file_path": str, # The absolute path to the file to read2446 "file_path": str, # Il percorso assoluto del file da leggere

2447 "offset": int | None, # The line number to start reading from2447 "offset": int | None, # Il numero di riga da cui iniziare la lettura

2448 "limit": int | None, # The number of lines to read2448 "limit": int | None, # Il numero di righe da leggere

2449}2449}

2450```2450```

2451 2451

2453 2453

2454```python theme={null}2454```python theme={null}

2455{2455{

2456 "content": str, # File contents with line numbers2456 "content": str, # Contenuto del file con numeri di riga

2457 "total_lines": int, # Total number of lines in file2457 "total_lines": int, # Numero totale di righe nel file

2458 "lines_returned": int, # Lines actually returned2458 "lines_returned": int, # Righe effettivamente restituite

2459}2459}

2460```2460```

2461 2461

2463 2463

2464```python theme={null}2464```python theme={null}

2465{2465{

2466 "image": str, # Base64 encoded image data2466 "image": str, # Dati dell'immagine codificati in Base64

2467 "mime_type": str, # Image MIME type2467 "mime_type": str, # Tipo MIME dell'immagine

2468 "file_size": int, # File size in bytes2468 "file_size": int, # Dimensione del file in byte

2469}2469}

2470```2470```

2471 2471

2477 2477

2478```python theme={null}2478```python theme={null}

2479{2479{

2480 "file_path": str, # The absolute path to the file to write2480 "file_path": str, # Il percorso assoluto del file da scrivere

2481 "content": str, # The content to write to the file2481 "content": str, # Il contenuto da scrivere nel file

2482}2482}

2483```2483```

2484 2484

2486 2486

2487```python theme={null}2487```python theme={null}

2488{2488{

2489 "message": str, # Success message2489 "message": str, # Messaggio di successo

2490 "bytes_written": int, # Number of bytes written2490 "bytes_written": int, # Numero di byte scritti

2491 "file_path": str, # File path that was written2491 "file_path": str, # Percorso del file che è stato scritto

2492}2492}

2493```2493```

2494 2494

2500 2500

2501```python theme={null}2501```python theme={null}

2502{2502{

2503 "pattern": str, # The glob pattern to match files against2503 "pattern": str, # Il pattern glob per abbinare i file

2504 "path": str | None, # The directory to search in (defaults to cwd)2504 "path": str | None, # La directory da cercare (default cwd)

2505}2505}

2506```2506```

2507 2507

2509 2509

2510```python theme={null}2510```python theme={null}

2511{2511{

2512 "matches": list[str], # Array of matching file paths2512 "matches": list[str], # Array dei percorsi dei file corrispondenti

2513 "count": int, # Number of matches found2513 "count": int, # Numero di corrispondenze trovate

2514 "search_path": str, # Search directory used2514 "search_path": str, # Directory di ricerca utilizzata

2515}2515}

2516```2516```

2517 2517

2523 2523

2524```python theme={null}2524```python theme={null}

2525{2525{

2526 "pattern": str, # The regular expression pattern2526 "pattern": str, # Il pattern di espressione regolare

2527 "path": str | None, # File or directory to search in2527 "path": str | None, # File o directory da cercare

2528 "glob": str | None, # Glob pattern to filter files2528 "glob": str | None, # Pattern glob per filtrare i file

2529 "type": str | None, # File type to search2529 "type": str | None, # Tipo di file da cercare

2530 "output_mode": str | None, # "content", "files_with_matches", or "count"2530 "output_mode": str | None, # "content", "files_with_matches", o "count"

2531 "-i": bool | None, # Case insensitive search2531 "-i": bool | None, # Ricerca senza distinzione maiuscole/minuscole

2532 "-n": bool | None, # Show line numbers2532 "-n": bool | None, # Mostra i numeri di riga

2533 "-B": int | None, # Lines to show before each match2533 "-B": int | None, # Righe da mostrare prima di ogni corrispondenza

2534 "-A": int | None, # Lines to show after each match2534 "-A": int | None, # Righe da mostrare dopo ogni corrispondenza

2535 "-C": int | None, # Lines to show before and after2535 "-C": int | None, # Righe da mostrare prima e dopo

2536 "head_limit": int | None, # Limit output to first N lines/entries2536 "head_limit": int | None, # Limita l'output alle prime N righe/voci

2537 "multiline": bool | None, # Enable multiline mode2537 "multiline": bool | None, # Abilita la modalità multilinea

2538}2538}

2539```2539```

2540 2540

2559 2559

2560```python theme={null}2560```python theme={null}

2561{2561{

2562 "files": list[str], # Files containing matches2562 "files": list[str], # File contenenti corrispondenze

2563 "count": int, # Number of files with matches2563 "count": int, # Numero di file con corrispondenze

2564}2564}

2565```2565```

2566 2566

2572 2572

2573```python theme={null}2573```python theme={null}

2574{2574{

2575 "notebook_path": str, # Absolute path to the Jupyter notebook2575 "notebook_path": str, # Percorso assoluto del notebook Jupyter

2576 "cell_id": str | None, # The ID of the cell to edit2576 "cell_id": str | None, # L'ID della cella da modificare

2577 "new_source": str, # The new source for the cell2577 "new_source": str, # La nuova sorgente per la cella

2578 "cell_type": "code" | "markdown" | None, # The type of the cell2578 "cell_type": "code" | "markdown" | None, # Il tipo della cella

2580}2580}

2581```2581```

2582 2582

2584 2584

2585```python theme={null}2585```python theme={null}

2586{2586{

2587 "message": str, # Success message2587 "message": str, # Messaggio di successo

2588 "edit_type": "replaced" | "inserted" | "deleted", # Type of edit performed2588 "edit_type": "replaced" | "inserted" | "deleted", # Tipo di modifica eseguita

2589 "cell_id": str | None, # Cell ID that was affected2589 "cell_id": str | None, # ID della cella interessata

2590 "total_cells": int, # Total cells in notebook after edit2590 "total_cells": int, # Numero totale di celle nel notebook dopo la modifica

2591}2591}

2592```2592```

2593 2593

2599 2599

2600```python theme={null}2600```python theme={null}

2601{2601{

2602 "url": str, # The URL to fetch content from2602 "url": str, # L'URL da cui recuperare il contenuto

2603 "prompt": str, # The prompt to run on the fetched content2603 "prompt": str, # Il prompt da eseguire sul contenuto recuperato

2604}2604}

2605```2605```

2606 2606

2608 2608

2609```python theme={null}2609```python theme={null}

2610{2610{

2611 "response": str, # AI model's response to the prompt2611 "bytes": int, # Dimensione del contenuto recuperato in byte

2612 "url": str, # URL that was fetched2612 "code": int, # Codice di risposta HTTP

2613 "final_url": str | None, # Final URL after redirects2613 "codeText": str, # Testo del codice di risposta HTTP

2614 "status_code": int | None, # HTTP status code2614 "result": str, # Risultato elaborato dall'applicazione del prompt al contenuto

2615 "durationMs": int, # Tempo per recuperare ed elaborare il contenuto, in millisecondi

2616 "url": str, # URL che è stato recuperato

2615}2617}

2616```2618```

2617 2619

2623 2625

2624```python theme={null}2626```python theme={null}

2625{2627{

2626 "query": str, # The search query to use2628 "query": str, # La query di ricerca da utilizzare

2627 "allowed_domains": list[str] | None, # Only include results from these domains2629 "allowed_domains": list[str] | None, # Includi solo risultati da questi domini

2628 "blocked_domains": list[str] | None, # Never include results from these domains2630 "blocked_domains": list[str] | None, # Non includere mai risultati da questi domini

2629}2631}

2630```2632```

2631 2633

2633 2635

2634```python theme={null}2636```python theme={null}

2635{2637{

2636 "results": [{"title": str, "url": str, "snippet": str, "metadata": dict | None}],2638 "query": str, # La query di ricerca

2637 "total_results": int,2639 "results": list[str | {"tool_use_id": str, "content": list[{"title": str, "url": str}]}],

2638 "query": str,2640 "durationSeconds": float, # Durata della ricerca in secondi

2639}2641}

2640```2642```

2641 2643

2649{2651{

2650 "todos": [2652 "todos": [

2651 {2653 {

2652 "content": str, # The task description2654 "content": str, # La descrizione del compito

2653 "status": "pending" | "in_progress" | "completed", # Task status2655 "status": "pending" | "in_progress" | "completed", # Stato del compito

2654 "activeForm": str, # Active form of the description2656 "activeForm": str, # Forma attiva della descrizione

2655 }2657 }

2656 ]2658 ]

2657}2659}

2661 2663

2662```python theme={null}2664```python theme={null}

2663{2665{

2664 "message": str, # Success message2666 "message": str, # Messaggio di successo

2665 "stats": {"total": int, "pending": int, "in_progress": int, "completed": int},2667 "stats": {"total": int, "pending": int, "in_progress": int, "completed": int},

2666}2668}

2667```2669```

2674 2676

2675```python theme={null}2677```python theme={null}

2676{2678{

2677 "bash_id": str, # The ID of the background shell2679 "bash_id": str, # L'ID della shell in background

2678 "filter": str | None, # Optional regex to filter output lines2680 "filter": str | None, # Regex opzionale per filtrare le righe di output

2679}2681}

2680```2682```

2681 2683

2683 2685

2684```python theme={null}2686```python theme={null}

2685{2687{

2686 "output": str, # New output since last check2688 "output": str, # Nuovo output dall'ultimo controllo

2687 "status": "running" | "completed" | "failed", # Current shell status2689 "status": "running" | "completed" | "failed", # Stato attuale della shell

2688 "exitCode": int | None, # Exit code when completed2690 "exitCode": int | None, # Codice di uscita al completamento

2689}2691}

2690```2692```

2691 2693

2697 2699

2698```python theme={null}2700```python theme={null}

2699{2701{

2700 "shell_id": str # The ID of the background shell to kill2702 "shell_id": str # L'ID della shell in background da terminare

2701}2703}

2702```2704```

2703 2705

2705 2707

2706```python theme={null}2708```python theme={null}

2707{2709{

2708 "message": str, # Success message2710 "message": str, # Messaggio di successo

2709 "shell_id": str, # ID of the killed shell2711 "shell_id": str, # ID della shell terminata

2710}2712}

2711```2713```

2712 2714

2718 2720

2719```python theme={null}2721```python theme={null}

2720{2722{

2721 "plan": str # The plan to run by the user for approval2723 "plan": str # Il piano da eseguire dall'utente per l'approvazione

2722}2724}

2723```2725```

2724 2726

2726 2728

2727```python theme={null}2729```python theme={null}

2728{2730{

2729 "message": str, # Confirmation message2731 "message": str, # Messaggio di conferma

2730 "approved": bool | None, # Whether user approved the plan2732 "approved": bool | None, # Se l'utente ha approvato il piano

2731}2733}

2732```2734```

2733 2735

2739 2741

2740```python theme={null}2742```python theme={null}

2741{2743{

2742 "server": str | None # Optional server name to filter resources by2744 "server": str | None # Nome del server opzionale per filtrare le risorse

2743}2745}

2744```2746```

2745 2747

2768 2770

2769```python theme={null}2771```python theme={null}

2770{2772{

2771 "server": str, # The MCP server name2773 "server": str, # Il nome del server MCP

2772 "uri": str, # The resource URI to read2774 "uri": str, # L'URI della risorsa da leggere

2773}2775}

2774```2776```

2775 2777

agent-sdk/quickstart.md +3 −2

Details

75 L'SDK supporta anche l'autenticazione tramite provider API di terze parti:75 L'SDK supporta anche l'autenticazione tramite provider API di terze parti:

76 76

77 * **Amazon Bedrock**: imposta la variabile di ambiente `CLAUDE_CODE_USE_BEDROCK=1` e configura le credenziali AWS77 * **Amazon Bedrock**: imposta la variabile di ambiente `CLAUDE_CODE_USE_BEDROCK=1` e configura le credenziali AWS

78 * **Claude Platform on AWS**: imposta `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` e `ANTHROPIC_AWS_WORKSPACE_ID`, quindi configura le credenziali AWS

78 * **Google Vertex AI**: imposta la variabile di ambiente `CLAUDE_CODE_USE_VERTEX=1` e configura le credenziali Google Cloud79 * **Google Vertex AI**: imposta la variabile di ambiente `CLAUDE_CODE_USE_VERTEX=1` e configura le credenziali Google Cloud

79 * **Microsoft Azure**: imposta la variabile di ambiente `CLAUDE_CODE_USE_FOUNDRY=1` e configura le credenziali Azure80 * **Microsoft Azure**: imposta la variabile di ambiente `CLAUDE_CODE_USE_FOUNDRY=1` e configura le credenziali Azure

80 81

~~81 Consulta le guide di configurazione per [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai), o [Azure AI Foundry](/it/microsoft-foundry) per i dettagli.~~82 Consulta le guide di configurazione per [Bedrock](/it/amazon-bedrock), [Claude Platform on AWS](/it/claude-platform-on-aws), [Vertex AI](/it/google-vertex-ai), o [Azure AI Foundry](/it/microsoft-foundry) per i dettagli.

82 83

83 <Note>84 <Note>

84 Se non precedentemente approvato, Anthropic non consente agli sviluppatori di terze parti di offrire il login claude.ai o limiti di velocità per i loro prodotti, inclusi gli agenti costruiti su Agent SDK di Claude. Utilizza invece i metodi di autenticazione con chiave API descritti in questo documento.85 Se non precedentemente approvato, Anthropic non consente agli sviluppatori di terze parti di offrire il login claude.ai o limiti di velocità per i loro prodotti, inclusi gli agenti costruiti su Agent SDK di Claude. Utilizza invece i metodi di autenticazione con chiave API descritti in questo documento.

173 174

1742. **`prompt`**: quello che vuoi che Claude faccia. Claude capisce quali strumenti usare in base al compito.1752. **`prompt`**: quello che vuoi che Claude faccia. Claude capisce quali strumenti usare in base al compito.

175 176

1763. **`options`**: configurazione per l'agente. Questo esempio utilizza `allowedTools` per pre-approvare `Read`, `Edit` e `Glob`, e `permissionMode: "acceptEdits"` per auto-approvare i cambiamenti ai file. Altre opzioni includono `systemPrompt`, `mcpServers` e altro. Vedi tutte le opzioni per [Python](/it/agent-sdk/python#claude-agent-options) o [TypeScript](/it/agent-sdk/typescript#options).1773. **`options`**: configurazione per l'agente. Questo esempio utilizza `allowedTools` per pre-approvare `Read`, `Edit` e `Glob`, e `permissionMode: "acceptEdits"` per auto-approvare i cambiamenti ai file. Altre opzioni includono `systemPrompt`, `mcpServers` e altro. Vedi tutte le opzioni per [Python](/it/agent-sdk/python#claudeagentoptions) o [TypeScript](/it/agent-sdk/typescript#options).

177 178

178Il loop `async for` continua a funzionare mentre Claude pensa, chiama strumenti, osserva i risultati e decide cosa fare dopo. Ogni iterazione produce un messaggio: il ragionamento di Claude, una chiamata a uno strumento, un risultato dello strumento, o il risultato finale. L'SDK gestisce l'orchestrazione (esecuzione dello strumento, gestione del contesto, tentativi) quindi consumi semplicemente il flusso. Il loop termina quando Claude completa il compito o incontra un errore.179Il loop `async for` continua a funzionare mentre Claude pensa, chiama strumenti, osserva i risultati e decide cosa fare dopo. Ogni iterazione produce un messaggio: il ragionamento di Claude, una chiamata a uno strumento, un risultato dello strumento, o il risultato finale. L'SDK gestisce l'orchestrazione (esecuzione dello strumento, gestione del contesto, tentativi) quindi consumi semplicemente il flusso. Il loop termina quando Claude completa il compito o incontra un errore.

179 180

agent-view.md +295 −0 created

Details

1> ## Documentation Index

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

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

5# Gestire più agenti con agent view

7> Invia e gestisci molte sessioni di Claude Code da una sola schermata. Agent view mostra cosa sta facendo ogni sessione e quali hanno bisogno del tuo input.

9Agent view, aperto con `claude agents`, è una sola schermata per tutte le tue sessioni in background: cosa sta girando, cosa ha bisogno del tuo input e cosa è fatto. Invia nuove sessioni, osserva il loro stato a colpo d'occhio invece di scorrere i transcript, e intervieni solo quando uno ne ha bisogno. Le sessioni continuano a girare in background senza un terminale collegato.

11Usa agent view quando hai diversi compiti indipendenti su cui Claude può lavorare contemporaneamente, come correggere un bug, revisionare una pull request o investigare un log. Quando vuoi lavorare insieme a un problema, collegati a una sessione e usa Claude Code in modo interattivo come al solito.

13Le sessioni in agent view vengono eseguite in modo indipendente e riferiscono solo a te. Per confrontare con subagenti, team di agenti e worktrees, vedi [Run agents in parallel](/it/agents).

15<Note>

16 Agent view è un'anteprima di ricerca e richiede Claude Code v2.1.139 o successivo. Controlla la tua versione con `claude --version`. L'interfaccia e le scorciatoie da tastiera potrebbero cambiare mentre la funzione si evolve, e gli amministratori possono disabilitare agent view per un'organizzazione con l'impostazione gestita [`disableAgentView`](#how-background-sessions-are-hosted).

17</Note>

19Questa pagina copre:

21* [Quick start](#quick-start)

22* [Monitor sessions with agent view](#monitor-sessions-with-agent-view), inclusi icone di stato, peek e reply, collegamento, organizzazione e scorciatoie da tastiera

23* [Dispatch new agents](#dispatch-new-agents) da agent view, da dentro una sessione, o dalla shell

24* [Manage sessions from the shell](#manage-sessions-from-the-shell)

25* [How background sessions are hosted](#how-background-sessions-are-hosted) dal processo supervisor

27## Quick start

29Questa procedura apre agent view, invia una sessione, risponde dal pannello peek e si collega per la conversazione completa.

31<Steps>

32 <Step title="Open agent view">

33 Dalla tua shell, esegui:

35 ```bash theme={null}

36 claude agents

37 ```

39 Agent view si apre con un input in basso e una tabella che si riempie quando le sessioni iniziano. Premi `Esc` in qualsiasi momento per uscire. Le tue sessioni continuano a girare.

40 </Step>

42 <Step title="Dispatch a session">

43 Digita un prompt nell'input e premi `Enter`. Una nuova sessione inizia e appare come una riga che mostra se sta lavorando, aspettando te, o è fatta. Ripeti per eseguire quante sessioni in parallelo vuoi.

44 </Step>

46 <Step title="Peek and reply">

47 Seleziona una riga con i tasti freccia e premi `Space` per vedere cosa sta facendo la sessione o cosa ha bisogno da te. Digita una risposta e premi `Enter` per inviarla senza lasciare agent view.

48 </Step>

50 <Step title="Attach and detach">

51 Premi `Enter` o `→` su una riga per collegarti quando vuoi la conversazione completa. La sessione prende il controllo del terminale esattamente come se avessi eseguito `claude`. Premi `←` su un prompt vuoto per scollegar e tornare alla tabella.

52 </Step>

53</Steps>

55Per portare una sessione interattiva esistente in agent view, esegui `/bg` dentro di essa, o premi `←` su un prompt vuoto per mettere la sessione in background e aprire agent view in un unico passaggio. La sessione continua a girare in background e appare come una riga. Per avviare una nuova sessione in background direttamente dalla shell, esegui `claude --bg "<prompt>"`.

57Puoi usare `claude agents` come tuo punto di ingresso principale invece di `claude`: invia ogni compito da agent view, collegati quando vuoi la conversazione completa, e premi `←` per tornare alla tabella.

59## Monitor sessions with agent view

61Esegui `claude agents` per aprire agent view. Prende il controllo del terminale completo ed elenca ogni sessione raggruppata per stato, con sessioni fissate e quelle che hanno bisogno di te in cima. Ogni riga mostra il nome della sessione, l'attività corrente e quanto tempo fa è cambiata l'ultima volta.

63L'elenco è globale per la tua macchina e include ogni sessione in background indipendentemente da quale progetto o worktree su cui sta lavorando. Le sessioni interattive che hai aperto in altri terminali non appaiono finché non le [metti in background](#from-inside-a-session), e i [subagents](/it/sub-agents) in esecuzione dentro una sessione non sono elencati come righe separate.

65```text theme={null}

66Pinned

67 ✽ clawd walk cycle Write assets/sprites/clawd-walk.png 3m

69Ready for review

70 ∙ jump physics github.com/anthropics/example/pull/2048 2h

72Needs input

73 ✻ power-up design needs input: double jump or wall climb? 1m

75Working

76 ✽ collision detection Edit src/physics/CollisionSystem.ts 2m

77 ✢ playtest level 3 run 12 · all checkpoints cleared in 4m

79Completed

80 ✻ title screen result: menu, options, and credits done 9m

81 ∙ sound effects result: 14 SFX exported to assets/audio 4h

82 … 6 more

83```

85L'icona ti dice lo stato della sessione:

87| Icon | State | What it means |

88| :------- | :---------- | :--------------------------------------------------------------------------------------- |

89| Animated | Working | Claude sta attivamente eseguendo strumenti o generando una risposta |

90| Yellow | Needs input | Claude sta aspettando il tuo input, solitamente una decisione di permesso o una risposta |

91| Dimmed | Idle | La sessione sta aspettando input ma non è bloccata su una domanda specifica |

92| Green | Completed | Il compito è terminato con successo |

93| Red | Failed | Il compito è terminato con un errore |

94| Grey | Stopped | La sessione è stata fermata con `Ctrl+X` o `claude stop` |

96La forma dell'icona ti dice se il processo sottostante è ancora in esecuzione. Un `✻`, o un `✽` animato mentre Claude sta lavorando, significa che la sessione è viva e puoi rispondere immediatamente. Un `∙` significa che il processo è uscito, ma puoi ancora fare peek, rispondere o collegarti: Claude riavvia la sessione da dove l'ha lasciata. Un `✢` è una sessione [`/loop`](/it/commands) che dorme tra le iterazioni, con la riga che mostra il conteggio delle esecuzioni e un conto alla rovescia per la prossima iterazione.

98Le sessioni in background non hanno bisogno di alcun terminale aperto per continuare a lavorare. Un [processo supervisor](#how-background-sessions-are-hosted) separato le esegue, quindi puoi chiudere agent view, chiudere la tua shell, o avviare una nuova sessione interattiva e il tuo lavoro inviato continua.

100Le sessioni persistono su disco: chiudere il tuo terminale o un auto-update non le perde, e riaprire `claude agents` le mostra tutte. Se la tua macchina dorme o si spegne, le sessioni in esecuzione si fermano; riavviale con `claude respawn --all`.

101

102Il riassunto di una riga è generato dal tuo [modello di classe Haiku](/it/model-config) configurato in modo che la riga possa dirti cosa sta facendo la sessione, cosa ha bisogno, o cosa ha prodotto senza aprire il transcript. Ogni riassunto è una breve richiesta di classe Haiku attraverso il tuo provider normale, fatturato e gestito secondo gli stessi [termini di utilizzo dei dati](/it/data-usage) della sessione stessa.

103

104Quando una sessione apre una pull request, la riga mostra il link PR e un indicatore di stato per i suoi controlli CI. Per la maggior parte dei compiti questa riga è come raccogli il lavoro: rivedi e unisci la pull request quando i suoi controlli passano.

105

106### Peek and reply

107

108Premi `Space` su una riga selezionata per aprire il pannello peek. Mostra cosa la sessione ha bisogno da te, il suo output più recente, e qualsiasi pull request che ha aperto. La maggior parte delle volte questo è sufficiente, e non hai mai bisogno di aprire il transcript completo.

109

110Digita una risposta nel pannello peek e premi `Enter` per inviarla a quella sessione. Quando la sessione sta facendo una domanda a scelta multipla, il pannello peek mostra le opzioni e puoi premere un tasto numero per sceglierne uno. Per altre sessioni bloccate, premi `Tab` per riempire l'input con una risposta suggerita che puoi modificare prima di inviare. Prefissa una risposta con `!` per inviare un comando Bash invece.

111

112Usa `↑` e `↓` per fare peek alle sessioni adiacenti senza chiudere il pannello, o `→` per collegarti.

113

114### Attach to a session

115

116Premi `Enter` o `→` su una riga selezionata per collegarti, o premi `Alt+1` fino a `Alt+9` per collegarti direttamente alla N-esima sessione nel gruppo focalizzato. Agent view è sostituito dalla sessione interattiva completa, esattamente come se avessi eseguito `claude` in quella directory. Quando ti colleghi, Claude pubblica un breve riassunto di cosa è successo mentre eri via.

117

118Mentre collegato, la sessione si comporta come qualsiasi altra sessione di Claude Code: ogni [comando](/it/commands), scorciatoia da tastiera e funzione funziona.

119

120Premi `←` su un prompt vuoto per scollegar e tornare a agent view. Se una finestra di dialogo ha il focus e non risponde a `←`, premi `Ctrl+Z` per scollegar immediatamente.

121

122Scollegar non ferma mai una sessione in background: `←`, `Ctrl+C`, `Ctrl+D`, `Ctrl+Z`, e `/exit` la lasciano tutte in esecuzione. Per terminare una sessione da dentro di essa, esegui `/stop`.

123

124Una volta che hai usato agent view, premere `←` su un prompt vuoto funziona da qualsiasi sessione di Claude Code, non solo quelle a cui ti sei collegato. Apre agent view con la tua sessione corrente pre-selezionata, quindi puoi cambiare sessioni senza lasciare il terminale.

125

126### Organize the list

127

128Agent view raggruppa le sessioni per stato, con sessioni che hanno bisogno di input sopra le sessioni che stanno lavorando o sono fatte. Premi `Ctrl+S` per passare al raggruppamento per directory invece. La tua scelta è salvata tra le esecuzioni. All'interno di un gruppo, fissa una sessione in cima con `Ctrl+T`, riordina con `Shift+↑` e `Shift+↓`, o premi `Enter` su un'intestazione di gruppo per comprimerla. Per rimuovere una sessione, premi `Ctrl+X` per fermarla e `Ctrl+X` di nuovo entro due secondi per eliminarla. Premere `Ctrl+X` su un'intestazione di gruppo elimina ogni sessione in quel gruppo dopo conferma.

129

130Le sessioni completate più vecchie si ripiegano in una riga "… N more" per mantenere l'elenco breve. I fallimenti e le sessioni con una pull request aperta rimangono sempre visibili.

131

132### Filter the list

133

134Digita nell'input di dispatch per filtrare invece di inviare:

135

136| Filter | Shows |

137| :---------------------- | :------------------------------------------------------------------------------- |

138| `a:<name>` | Sessioni che eseguono l'agente denominato |

139| `s:<state>` | Sessioni nello stato dato, come `s:blocked` per sessioni che hanno bisogno di te |

140| `#<number>` o un URL PR | La sessione che lavora su quella pull request |

141

142### Keyboard shortcuts

143

144Premi `?` in agent view per vedere ogni scorciatoia. Le più comuni:

145

146| Shortcut | Action |

147| :-------------------- | :------------------------------------------------------------------- |

148| `↑` / `↓` | Muoviti tra le righe |

149| `Enter` | Collegati alla sessione selezionata, o invia se c'è testo nell'input |

150| `Space` | Apri o chiudi il pannello peek per la sessione selezionata |

151| `Shift+Enter` | Invia e collegati immediatamente |

152| `→` | Collegati alla sessione selezionata |

153| `Alt+1`..`Alt+9` | Collegati alla N-esima sessione nel gruppo focalizzato |

154| `Tab` | Sfoglia tutti i subagents, o applica il suggerimento evidenziato |

155| `Ctrl+S` | Cambia raggruppamento tra stato e directory |

156| `Ctrl+T` | Fissa o scollega la sessione selezionata |

157| `Ctrl+R` | Rinomina la sessione selezionata |

158| `Ctrl+G` | Apri il prompt di dispatch nel tuo `$EDITOR` |

159| `Ctrl+X` | Ferma la sessione; premi di nuovo entro due secondi per eliminarla |

160| `Shift+↑` / `Shift+↓` | Riordina la sessione selezionata |

161| `Esc` | Chiudi il pannello peek, cancella l'input, o esci |

162| `Ctrl+C` | Cancella l'input; premi due volte per uscire |

163| `?` | Mostra tutte le scorciatoie |

164

165## Dispatch new agents

166

167Puoi inviare nuove sessioni in background da agent view, inviare una sessione interattiva esistente in background, o avviarne una direttamente dalla shell.

168

169### From agent view

170

171Digita un prompt nell'input in basso di agent view e premi `Enter` per avviare una nuova sessione in background. La sessione è denominata automaticamente dal prompt. Puoi rinominarla in seguito con `Ctrl+R`. Incolla un'immagine nel prompt per includere uno screenshot o un diagramma con il compito.

172

173Prefissa o menziona parti del prompt per controllare come la sessione inizia:

174

175| Input | Effect |

176| :----------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

177| `<agent-name> <prompt>` | Se la prima parola corrisponde a un nome di [subagent](/it/sub-agents) personalizzato, quel subagent viene eseguito come agente principale della sessione con la configurazione dal suo frontmatter |

178| `@<agent-name>` | Menziona un subagent personalizzato in qualsiasi punto del prompt per eseguirlo come agente principale |

179| `@<repo>` | Menziona un repository sotto la directory da cui hai aperto agent view per eseguire la sessione lì |

180| `/<skill>` | Suggerisci [skills](/it/skills) da inviare come prompt |

181| `#<number>` o un URL di pull request | Se una sessione sta già lavorando su quel PR, selezionala invece di inviare |

182| `Shift+Enter` | Invia e collegati immediatamente alla nuova sessione |

183

184Digita `/` per inviare una [skill](/it/skills). Confezionare un compito ricorrente come una skill ti permette di avviare lo stesso workflow molte volte da agent view senza riscrivere il prompt. Premi `Tab` su un input vuoto per sfogliare ogni subagent inviabile, o per applicare il suggerimento evidenziato quando i suggerimenti sono mostrati.

185

186#### Dispatch to a specific directory

187

188Una nuova sessione viene eseguita nella directory da cui hai aperto agent view. Per indirizzare una directory diversa:

189

190* Apri `claude agents` in quella directory.

191* Apri `claude agents` in una directory padre che contiene diversi repository e menzionane uno con `@<repo>` nel prompt per eseguire la sessione lì.

192* Dalla shell, `cd` nella directory e esegui `claude --bg "<prompt>"`.

193

194Quando agent view è raggruppato per directory, la directory della riga evidenziata diventa il target di dispatch, quindi puoi scorrere a un gruppo e inviare in esso senza riscrivere il percorso.

195

196#### Isolate file edits in a worktree

197

198Le sessioni inviate da agent view condividono la tua directory di lavoro per impostazione predefinita, quindi due agenti che modificano gli stessi file possono entrare in conflitto. Per prevenire questo, Claude Code blocca una sessione inviata da agent view dalla scrittura di file finché non si sposta in un [git worktree](/it/worktrees) isolato. Claude gestisce questo automaticamente quando ha bisogno di modificare file. Il worktree è creato sotto `.claude/worktrees/` dentro la directory del progetto e rimosso quando elimini la sessione. Eliminare una sessione elimina anche il suo worktree, quindi unisci o spingi i cambiamenti che vuoi mantenere prima di eliminare.

199

200Per fare in modo che un subagent venga sempre eseguito nel suo proprio worktree indipendentemente da come è stato avviato, imposta [`isolation: worktree`](/it/sub-agents#supported-frontmatter-fields) nel suo frontmatter.

201

202### From inside a session

203

204Esegui `/background` o il suo alias `/bg` per scollegar la conversazione corrente e mantenerla in esecuzione. Passa un prompt come `/bg run the test suite and fix any failures` per inviare un'istruzione in più prima di scollegar.

205

206### From the shell

207

208Passa `--bg` per avviare una sessione che va direttamente in background:

209

210```bash theme={null}

211claude --bg "investigate the flaky SettingsChangeDetector test"

212```

213

214Per eseguire un subagent specifico come agente principale della sessione, combina `--bg` con `--agent`:

215

216```bash theme={null}

217claude --agent code-reviewer --bg "address review comments on PR 1234"

218```

219

220Dopo aver messo in background, Claude stampa l'ID breve della sessione e i comandi per gestirla:

221

222```text theme={null}

223backgrounded · 7c5dcf5d

224 claude agents list sessions

225 claude attach 7c5dcf5d open in this terminal

226 claude logs 7c5dcf5d show recent output

227 claude stop 7c5dcf5d stop this session

228```

229

230## Manage sessions from the shell

231

232Ogni sessione in background ha un ID breve che puoi usare dalla shell. Questi comandi sono utili per lo scripting o quando non vuoi aprire agent view.

233

234| Command | Purpose |

235| :--------------------- | :------------------------------------------------------------ |

236| `claude agents` | Apri agent view |

237| `claude attach <id>` | Collegati a una sessione in questo terminale |

238| `claude logs <id>` | Stampa l'output recente della sessione |

239| `claude stop <id>` | Ferma una sessione. Accetta anche `claude kill` |

240| `claude respawn <id>` | Riavvia una sessione fermata con la sua conversazione intatta |

241| `claude respawn --all` | Riavvia ogni sessione fermata |

242| `claude rm <id>` | Rimuovi una sessione dall'elenco |

243

244## How background sessions are hosted

245

246Le sessioni in background sono ospitate da un processo supervisor per utente, separato dal tuo terminale e da agent view. Si avvia automaticamente la prima volta che metti una sessione in background o apri agent view, e non lo gestisci direttamente. Il supervisor e le sue sessioni si autenticano con le stesse credenziali delle tue sessioni interattive e non fanno connessioni di rete aggiuntive oltre l'API del modello.

247

248Ogni sessione in background è il suo proprio processo di Claude Code, genitore del supervisor piuttosto che del tuo terminale. Una sessione che sta attivamente lavorando, aspettando il tuo input, o ha un terminale collegato mantiene il suo processo in esecuzione. Una volta che una sessione finisce e rimane scollega per circa un'ora, il supervisor ferma il suo processo per liberare risorse. Il transcript e lo stato rimangono su disco, e la prossima volta che ti colleghi, fai peek, o rispondi, il supervisor avvia un processo fresco da dove l'ha lasciato. Quando ogni sessione è finita e nessun terminale è collegato, il supervisor stesso esce e si avvia di nuovo la prossima volta che metti una sessione in background o apri agent view.

249

250Il supervisor osserva il binario di Claude Code installato su disco e si riavvia nella nuova versione dopo che l'[auto-updater](/it/setup#auto-updates) regolare lo sostituisce. Questo è un watch di file locale, non un controllo di rete. Le sessioni in background sono processi scollegati, quindi continuano a girare attraverso il riavvio e il nuovo supervisor si ricollega a loro.

251

252Lo stato della sessione è archiviato sotto la tua directory di configurazione di Claude Code. Se imposti [`CLAUDE_CONFIG_DIR`](/it/env-vars), il supervisor usa quella directory invece di `~/.claude` e viene eseguito come un'istanza separata con le sue proprie sessioni.

253

254| Path | Contents |

255| :------------------------------- | :---------------------------------------------------------------------------------------- |

256| `~/.claude/daemon.log` | Log del supervisor |

257| `~/.claude/daemon/roster.json` | Elenco delle sessioni in background in esecuzione, usato per ricollegarsi dopo un riavvio |

258| `~/.claude/jobs/<id>/state.json` | Stato per sessione mostrato in agent view |

259

260Per disattivare completamente gli agenti in background e agent view, imposta l'[impostazione](/it/settings) `disableAgentView` su `true` o imposta la variabile di ambiente `CLAUDE_CODE_DISABLE_AGENT_VIEW`. Gli amministratori possono applicare questo attraverso [impostazioni gestite](/it/permissions#managed-settings).

261

262## Troubleshooting

263

264### Agent view opens with no sessions

265

266Agent view è vuoto finché non invii la tua prima sessione. Digita un prompt nell'input in basso e premi `Enter`.

267

268### Sessions show as stopped after waking your machine

269

270Le sessioni in background non sopravvivono al sonno o allo spegnimento. Collegati, fai peek, o rispondi a qualsiasi sessione fermata e si riavvia da dove l'ha lasciata. Per riavviarle tutte contemporaneamente, esegui `claude respawn --all`.

271

272### A session is slow to respond after attaching

273

274Una volta che una sessione è finita e rimane scollega per circa un'ora, il supervisor ferma il suo processo per liberare risorse. Collegarsi avvia un processo fresco da dove l'ha lasciato, il che richiede un momento. Le sessioni che stanno lavorando o aspettando te non sono mai fermate in questo modo.

275

276### `.claude/worktrees/` is filling up

277

278I worktrees sono rimossi quando elimini la sessione che li ha creati. Se una sessione è terminata senza pulire, elenca le voci rimaste con `git worktree list` nella directory del progetto e rimuovi ognuna con `git worktree remove <path>`. Vedi [Clean up worktrees](/it/worktrees#clean-up-worktrees).

279

280## Limitations

281

282Agent view è un'anteprima di ricerca. Le limitazioni attuali di cui essere consapevoli:

283

284* **I limiti di velocità si applicano**: le sessioni in background consumano il tuo utilizzo di abbonamento come le sessioni interattive, quindi eseguire dieci agenti in parallelo usa la quota dieci volte più velocemente.

285* **Le sessioni sono locali**: le sessioni in background vengono eseguite sulla tua macchina e si fermano se dorme o si spegne.

286* **I worktrees vengono eliminati con la sessione**: unisci o spingi i cambiamenti prima di eliminare una sessione che ha modificato file nel suo proprio worktree.

287

288## Passaggi successivi

289

290Ora che comprendi agent view, esplora queste funzioni correlate:

291

292* [Esegui agenti in parallelo](/it/agents): confronta agent view con subagenti, team di agenti e worktrees

293* [Subagenti](/it/sub-agents): definisci configurazioni di agenti riutilizzabili con prompt personalizzati, strumenti e isolamento

294* [Team di agenti](/it/agent-teams): coordina più sessioni che si messaggiano l'una con l'altra

295* [Claude Code on the web](/it/claude-code-on-the-web): esegui sessioni in un ambiente cloud gestito invece che localmente

agents.md +52 −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# Eseguire agenti in parallelo

7> Confronta i modi in cui Claude Code può affrontare più attività contemporaneamente: subagenti, visualizzazione agenti, team di agenti e sessioni worktree isolate.

9[Subagenti](/it/sub-agents), [visualizzazione agenti](/it/agent-view), [team di agenti](/it/agent-teams) e [worktrees](/it/worktrees) parallelizzano il lavoro in modi diversi. Quello giusto dipende dal fatto che tu voglia rimanere in ogni conversazione tu stesso, delegare i compiti e controllare più tardi, oppure far coordinare a Claude un gruppo di lavoratori per te.

11| Approccio | Cosa ti offre | Usalo quando |

12| :--------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------ |

13| [Subagenti](/it/sub-agents) | Lavoratori delegati all'interno di una sessione che svolgono un compito secondario nel loro contesto e restituiscono un riepilogo | Un compito secondario allagherebbe la tua conversazione principale con risultati di ricerca, log o contenuti di file che non consulterai di nuovo |

14| [Visualizzazione agenti](/it/agent-view) | Una schermata per inviare e monitorare sessioni in esecuzione in background, aperta con `claude agents`. Anteprima di ricerca | Hai diversi compiti indipendenti e vuoi delegarli, controllare lo stato a colpo d'occhio e intervenire solo quando uno ha bisogno di te |

15| [Team di agenti](/it/agent-teams) | Più sessioni coordinate con un elenco di attività condiviso e messaggistica tra agenti, gestite da un leader. Sperimentale e disabilitato per impostazione predefinita | Vuoi che Claude divida un progetto in parti, le assegni e mantenga i lavoratori sincronizzati |

16| [Worktrees](/it/worktrees) | Checkout git separati in modo che le sessioni parallele non tocchino mai i file l'una dell'altra | Stai eseguendo diverse sessioni tu stesso, oppure i tuoi subagenti modificano file sovrapposti |

17| [`/batch`](/it/commands) | Una divisione pianificata di un grande cambiamento in 5-30 subagenti isolati da worktree che ciascuno apre una pull request | Una migrazione a livello di repository o un refactoring meccanico che puoi descrivere in un'istruzione |

19In ogni approccio i lavoratori sono sessioni Claude. Per coinvolgere uno strumento diverso, esponilo a Claude come [server MCP](/it/mcp).

21Puoi combinare questi approcci. La visualizzazione agenti sposta automaticamente ogni sessione inviata nel suo proprio worktree quando ha bisogno di modificare file, e una sessione in cui stai lavorando può generare subagenti che ciascuno ottiene il proprio worktree.

23<Note>

24 L'esecuzione di più sessioni o subagenti contemporaneamente moltiplica l'utilizzo dei token. Vedi [Costi](/it/costs) per i dettagli su utilizzo e limiti di velocità.

25</Note>

27## Scegli un approccio

29L'approccio giusto dipende da chi coordina il lavoro, dal fatto che i lavoratori debbano comunicare e dal fatto che modifichino gli stessi file:

31* **Chi coordina il lavoro?** Se vuoi che Claude deleghi e raccolga i risultati all'interno di una conversazione, usa [subagenti](/it/sub-agents). Se stai delegando compiti indipendenti e controllando di nuovo, usa [visualizzazione agenti](/it/agent-view). Se vuoi che Claude pianifichi, assegni e supervizioni un gruppo di lavoratori, usa [team di agenti](/it/agent-teams), che sono sperimentali e disabilitati per impostazione predefinita.

32* **I lavoratori hanno bisogno di parlarsi?** I subagenti riportano i risultati alla conversazione che li ha generati, e le sessioni di visualizzazione agenti riportano solo a te. I compagni di squadra in un team di agenti condividono un elenco di attività e si messaggiano direttamente.

33* **I compiti toccano gli stessi file?** Isola il lavoro con [worktrees](/it/worktrees). I subagenti e le sessioni che esegui tu stesso possono ciascuno utilizzare un worktree separato. I team di agenti non isolano i compagni di squadra nei worktrees, quindi [partiziona il lavoro](/it/agent-teams#avoid-file-conflicts) in modo che ogni compagno di squadra possieda un set diverso di file.

35## Controlla il lavoro in esecuzione

37Il comando per controllare il lavoro in esecuzione dipende da quale approccio hai utilizzato:

39* Per le sessioni in background, `claude agents` apre [visualizzazione agenti](/it/agent-view): una schermata che mostra ogni sessione, il suo stato e quali hanno bisogno del tuo input.

40* Per i subagenti nella sessione corrente, `/agents` apre un pannello con una scheda **Running** che elenca i subagenti attivi e una scheda **Library** dove [crei e modifichi subagenti personalizzati](/it/sub-agents#use-the-%2Fagents-command). Nonostante il nome simile, questo è separato da `claude agents`.

41* Per qualsiasi cosa in esecuzione in background della sessione corrente, `/tasks` elenca ogni elemento e ti consente di controllare, collegarti o interrompere.

43Per una visualizzazione desktop di tutte le tue sessioni, vedi [sessioni parallele nell'app desktop](/it/desktop#work-in-parallel-with-sessions).

45## Scopri di più

47Ogni guida di seguito copre la configurazione e la configurazione per un approccio:

49* [Crea subagenti personalizzati](/it/sub-agents): definisci specialisti riutilizzabili e controlla quali strumenti possono utilizzare.

50* [Gestisci agenti con visualizzazione agenti](/it/agent-view): invia sessioni, osserva il loro stato e collegati quando uno ha bisogno di te.

51* [Orchestra team di agenti](/it/agent-teams): configura un leader e compagni di squadra, assegna compiti e rivedi il loro lavoro.

52* [Esegui sessioni parallele con worktrees](/it/worktrees): avvia Claude in un checkout isolato, controlla cosa viene copiato e pulisci in seguito.

claude-platform-on-aws.md +341 −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# Claude Code su Claude Platform on AWS

7> Configura Claude Code per utilizzare l'API Claude gestita da Anthropic con autenticazione AWS, controllo dell'accesso IAM e fatturazione tramite AWS Marketplace.

9export const ContactSalesCard = ({surface}) => {

10 const utm = content => `utm_source=claude_code&utm_medium=docs&utm_content=${surface}_${content}`;

11 const iconArrowRight = (size = 13) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

12 <line x1="5" y1="12" x2="19" y2="12" />

13 <polyline points="12 5 19 12 12 19" />

14 </svg>;

15 const STYLES = `

16.cc-cs {

17 --cs-slate: #141413;

18 --cs-clay: #d97757;

19 --cs-clay-deep: #c6613f;

20 --cs-gray-000: #ffffff;

21 --cs-gray-700: #3d3d3a;

22 --cs-border-default: rgba(31, 30, 29, 0.15);

23 font-family: inherit;

24}

25.dark .cc-cs {

26 --cs-slate: #f0eee6;

27 --cs-gray-000: #262624;

28 --cs-gray-700: #bfbdb4;

29 --cs-border-default: rgba(240, 238, 230, 0.14);

30}

31.cc-cs-card {

32 display: flex; align-items: center; justify-content: space-between;

33 gap: 16px; padding: 14px 16px; margin: 0;

34 background: var(--cs-gray-000); border: 0.5px solid var(--cs-border-default);

35 border-radius: 8px; flex-wrap: wrap;

36}

37.cc-cs-text { font-size: 13px; color: var(--cs-gray-700); line-height: 1.5; flex: 1; min-width: 240px; }

38.cc-cs-text strong { font-weight: 550; color: var(--cs-slate); }

39.cc-cs-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }

40.cc-cs-btn-clay {

41 display: inline-flex; align-items: center; gap: 8px;

42 background: var(--cs-clay-deep); color: #fff; border: none;

43 border-radius: 8px; padding: 8px 14px;

44 font-size: 13px; font-weight: 500;

45 transition: background-color 0.15s; white-space: nowrap;

46}

47.cc-cs-btn-clay:hover { background: var(--cs-clay); }

48.cc-cs-btn-ghost {

49 display: inline-flex; align-items: center; gap: 8px;

50 background: transparent; color: var(--cs-gray-700);

51 border: 0.5px solid var(--cs-border-default);

52 border-radius: 8px; padding: 8px 14px;

53 font-size: 13px; font-weight: 500;

54}

55.cc-cs-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

56.dark .cc-cs-btn-ghost:hover { background: rgba(255, 255, 255, 0.04); }

57@media (max-width: 720px) {

58 .cc-cs-actions { width: 100%; }

59}

60`;

61 return <div className="cc-cs not-prose">

62 <style>{STYLES}</style>

63 <div className="cc-cs-card">

64 <div className="cc-cs-text">

65 <strong>Deploying Claude Code across your organization?</strong> Talk to sales about enterprise plans, SSO, and centralized billing.

66 </div>

67 <div className="cc-cs-actions">

68 <a href={`https://claude.com/pricing?${utm('view_plans')}#plans-business`} className="cc-cs-btn-ghost">

69 View plans

70 </a>

71 <a href={`https://claude.com/contact-sales?${utm('contact_sales')}`} className="cc-cs-btn-clay">

72 Contact sales {iconArrowRight()}

73 </a>

74 </div>

75 </div>

76 </div>;

77};

79export const Experiment = ({flag, treatment, children}) => {

80 const VID_KEY = 'exp_vid';

81 const CONSENT_COUNTRIES = new Set(['AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU', 'MT', 'NL', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'RE', 'GP', 'MQ', 'GF', 'YT', 'BL', 'MF', 'PM', 'WF', 'PF', 'NC', 'AW', 'CW', 'SX', 'FO', 'GL', 'AX', 'GB', 'UK', 'AI', 'BM', 'IO', 'VG', 'KY', 'FK', 'GI', 'MS', 'PN', 'SH', 'TC', 'GG', 'JE', 'IM', 'CA', 'BR', 'IN']);

82 const fnv1a = s => {

83 let h = 0x811c9dc5;

84 for (let i = 0; i < s.length; i++) {

85 h ^= s.charCodeAt(i);

86 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);

87 }

88 return h >>> 0;

89 };

90 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';

91 const [decision] = useState(() => {

92 const params = new URLSearchParams(location.search);

93 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];

94 const force = params.get('gb-force');

95 if (force) {

96 for (const p of force.split(',')) {

97 const [k, v] = p.split(':');

98 if (k === flag) return {

99 variant: v || 'treatment',

100 track: false

101 };

102 }

103 }

104 if (navigator.globalPrivacyControl) {

105 return {

106 variant: 'control',

107 track: false

108 };

109 }

110 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

111 if (prefsMatch) {

112 try {

113 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

114 return {

115 variant: 'control',

116 track: false

117 };

118 }

119 } catch {

120 return {

121 variant: 'control',

122 track: false

123 };

124 }

125 } else {

126 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

127 if (!country || CONSENT_COUNTRIES.has(country)) {

128 return {

129 variant: 'control',

130 track: false

131 };

132 }

133 }

134 let vid;

135 try {

136 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

137 if (ajsMatch) {

138 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

139 } else {

140 vid = localStorage.getItem(VID_KEY);

141 if (!vid) {

142 vid = crypto.randomUUID();

143 }

144 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

145 }

146 try {

147 localStorage.setItem(VID_KEY, vid);

148 } catch {}

149 } catch {

150 return {

151 variant: 'control',

152 track: false

153 };

154 }

155 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

156 return {

157 variant,

158 track: true,

159 vid

160 };

161 });

162 useEffect(() => {

163 if (!decision.track) return;

164 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

165 method: 'POST',

166 headers: {

167 'Content-Type': 'application/json',

168 'x-service-name': 'claude_code_docs'

169 },

170 body: JSON.stringify({

171 events: [{

172 event_type: 'GrowthbookExperimentEvent',

173 event_data: {

174 device_id: decision.vid,

175 anonymous_id: decision.vid,

176 timestamp: new Date().toISOString(),

177 experiment_id: flag,

178 variation_id: decision.variant === 'treatment' ? 1 : 0,

179 environment: 'production'

180 }

181 }]

182 }),

183 keepalive: true

184 }).catch(() => {});

185 }, []);

186 return decision.variant === 'treatment' ? treatment : children;

187};

188

189<Experiment flag="docs-contact-sales-cta" treatment={<ContactSalesCard surface="claude_platform_on_aws" />} />

190

191Claude Platform on AWS è l'API Claude gestita da Anthropic con autenticazione AWS, controllo dell'accesso IAM e fatturazione tramite AWS Marketplace. Le richieste raggiungono direttamente l'API di Anthropic, quindi si ottengono gli stessi modelli e funzionalità dell'[API Claude](https://platform.claude.com/docs) con la stessa pianificazione dei rilasci. L'autenticazione avviene con le credenziali AWS o una chiave API dell'area di lavoro, e il pagamento avviene tramite AWS Marketplace.

192

193Utilizzare questa guida per indirizzare Claude Code a un'area di lavoro già fornita tramite Claude Platform on AWS. Per la sottoscrizione AWS e la configurazione dell'area di lavoro che precede questo, consultare la [documentazione di Claude Platform on AWS](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws).

194

195<Note>

196 L'iscrizione tramite AWS Marketplace fornisce una nuova organizzazione Anthropic collegata al proprio account AWS. Questa organizzazione è separata da qualsiasi organizzazione già presente con Anthropic e le credenziali non si trasferiscono tra loro. Utilizzare l'ID dell'area di lavoro e le chiavi API dall'organizzazione collegata ad AWS, non da un account Claude Console preesistente.

197</Note>

198

199## Prerequisiti

200

201Prima di configurare Claude Code, è necessario disporre di:

202

203* Una sottoscrizione attiva a Claude Platform on AWS tramite AWS Marketplace

204* Un'area di lavoro nella propria organizzazione Anthropic collegata ad AWS, con il relativo ID dell'area di lavoro

205* Un principale IAM con autorizzazione per invocare il servizio Anthropic, oppure una chiave API limitata all'area di lavoro

206* Credenziali AWS nel proprio ambiente, in `~/.aws/credentials`, o da un ruolo IAM collegato se si desidera l'autenticazione SigV4. L'AWS CLI è richiesta solo per il flusso di accesso SSO.

207

208## Configurazione

209

210### 1. Configurare le credenziali AWS

211

212Claude Code supporta due metodi di autenticazione per Claude Platform on AWS. Scegliere il metodo che si adatta al modo in cui il team gestisce l'accesso.

213

214**Opzione A: Credenziali AWS con SigV4**

215

216Claude Code firma le richieste con SigV4 utilizzando la catena di credenziali AWS standard: variabili di ambiente, credenziali condivise in `~/.aws/credentials`, ruoli IAM, sessioni AWS SSO e qualsiasi altra fonte supportata dall'SDK AWS.

217

218Per l'uso locale, accedere con l'AWS CLI prima di avviare Claude Code. L'esempio seguente utilizza un profilo SSO, ma qualsiasi metodo che produce credenziali nelle posizioni standard funziona.

219

220```bash theme={null}

221aws sso login --profile my-profile

222export AWS_PROFILE=my-profile

223```

224

225Per CI e automazione, fornire al runner un ruolo IAM con autorizzazione per invocare il servizio Anthropic e impostare `AWS_REGION`. La catena di credenziali raccoglie il ruolo automaticamente.

226

227Se le credenziali SSO scadono durante la sessione, configurare [`awsAuthRefresh`](/it/amazon-bedrock#advanced-credential-configuration) in modo che Claude Code riesegua il comando di accesso e riprovi invece di fallire. Aggiungere il comando al file `settings.json`:

228

229```json theme={null}

230{

231 "awsAuthRefresh": "aws sso login --profile my-profile"

232}

233```

234

235**Opzione B: Chiave API dell'area di lavoro**

236

237Una chiave API dell'area di lavoro è un segreto di lunga durata, utile quando non si desidera gestire credenziali AWS federate. Generarne una nella console AWS in **Claude Platform on AWS → API keys** e impostarla come `ANTHROPIC_AWS_API_KEY`:

238

239```bash theme={null}

240export ANTHROPIC_AWS_API_KEY=sk-ant-xxxxx

241```

242

243La chiave viene inviata come `x-api-key` e ha la precedenza su SigV4, quindi qualsiasi credenziale AWS nel proprio ambiente viene ignorata. Le chiavi API da un'organizzazione Claude Console separata non funzioneranno qui.

244

245Trattare le chiavi API dell'area di lavoro come qualsiasi altra credenziale di produzione. Il blocco `env` del [file delle impostazioni utente](/it/settings) è un modo conveniente per limitare la chiave alla propria macchina senza esportarla globalmente.

246

247<Note>

248 I comandi `/login` e `/logout` non modificano l'autenticazione di Claude Platform on AWS. L'autenticazione viene eseguita tramite le credenziali AWS o la chiave API dell'area di lavoro, non tramite una sottoscrizione Claude.ai.

249</Note>

250

251### 2. Configurare Claude Code

252

253Impostare le variabili di ambiente che indirizzano Claude Code attraverso Claude Platform on AWS invece dell'API Anthropic predefinita.

254

255```bash theme={null}

256export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

257export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

258export AWS_REGION=us-east-1

259```

260

261`ANTHROPIC_AWS_WORKSPACE_ID` è obbligatorio e viene inviato su ogni richiesta come intestazione `anthropic-workspace-id`. L'URL di base viene calcolato da `AWS_REGION` come `https://aws-external-anthropic.{region}.api.aws`. Per sovrascrivere l'URL direttamente, impostare `ANTHROPIC_AWS_BASE_URL`.

262

263Claude Platform on AWS è facoltativo anche quando le credenziali AWS sono presenti nel proprio ambiente. Bedrock e Foundry hanno la precedenza nel routing dei provider, quindi annullare l'impostazione di `CLAUDE_CODE_USE_BEDROCK` e `CLAUDE_CODE_USE_FOUNDRY` se sono impostati.

264

265### 3. Fissare le versioni dei modelli

266

267Claude Platform on AWS utilizza gli stessi ID modello dell'API Claude diretta. Gli alias predefiniti `opus`, `sonnet` e `haiku` si risolvono alle versioni più recenti disponibili nell'area di lavoro.

268

269Se si distribuisce Claude Code a un team, fissare esplicitamente gli ID modello in modo che un nuovo rilascio non sposti tutti contemporaneamente:

270

271```bash theme={null}

272export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-7

273export ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6

274export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5

275```

276

277Per l'elenco completo degli ID modello e degli alias, consultare [Panoramica dei modelli](https://platform.claude.com/docs/en/about-claude/models/overview). Per altre variabili relative ai modelli, consultare [Configurazione del modello](/it/model-config).

278

279[Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) è abilitato automaticamente. Le scritture della cache di 1 ora vengono fatturate a una tariffa più alta rispetto alle scritture di 5 minuti. Per richiedere un TTL della cache di 1 ora invece del valore predefinito di 5 minuti, impostare `ENABLE_PROMPT_CACHING_1H=1`.

280

281## Utilizzare l'Agent SDK

282

283L'[Agent SDK](/it/agent-sdk/overview) legge le stesse variabili di ambiente della CLI, quindi qualsiasi programma che genera il sottoprocesso Claude Code può indirizzare Claude Platform on AWS esportando `CLAUDE_CODE_USE_ANTHROPIC_AWS`, `ANTHROPIC_AWS_WORKSPACE_ID` e `ANTHROPIC_AWS_API_KEY` o credenziali AWS prima della chiamata.

284

285```typescript theme={null}

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

287

288process.env.CLAUDE_CODE_USE_ANTHROPIC_AWS = "1";

289process.env.ANTHROPIC_AWS_WORKSPACE_ID = "wrkspc_01ABCDEFGHIJKLMN";

290process.env.AWS_REGION = "us-east-1";

291

292for await (const msg of query({ prompt: "What's in this repo?" })) {

293 console.log(msg);

294}

295```

296

297Questo esempio si basa sulla catena di credenziali AWS ambientale per SigV4. Per autenticarsi con una chiave API dell'area di lavoro, impostare `ANTHROPIC_AWS_API_KEY` allo stesso modo. Per la superficie più ampia dell'Agent SDK, consultare [Panoramica dell'Agent SDK](/it/agent-sdk/overview).

298

299## Instradare attraverso un proxy aziendale

300

301Per instradare il traffico attraverso un proxy o un [gateway LLM](/it/llm-gateway), impostare `ANTHROPIC_AWS_BASE_URL` all'indirizzo del proxy. Claude Code invia richieste a quell'URL con le stesse intestazioni di area di lavoro e autenticazione, quindi qualsiasi gateway che le inoltri invariate funziona.

302

303```bash theme={null}

304export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

305export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

306export ANTHROPIC_AWS_BASE_URL=https://anthropic-proxy.example.com

307```

308

309Se il gateway firma le richieste stesso, impostare `CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1` in modo che Claude Code invii richieste non firmate e lasci che il gateway aggiunga intestazioni SigV4 prima di inoltrarle ad AWS. Se il gateway richiede il proprio token, impostarlo in `ANTHROPIC_AUTH_TOKEN`.

310

311```bash theme={null}

312export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

313export CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1

314export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

315export ANTHROPIC_AWS_BASE_URL=https://anthropic-proxy.example.com

316```

317

318## Troubleshooting

319

320Eseguire `/status` per visualizzare il provider risolto e qualsiasi ID dell'area di lavoro configurato esplicitamente, override della regione, override dell'URL di base e impostazione di skip dell'autenticazione. Questo è il modo più veloce per confermare che Claude Code sta indirizzando Claude Platform on AWS.

321

322### `403 Forbidden` o `AccessDenied` su ogni richiesta

323

324Il principale IAM che Claude Code ha risolto probabilmente manca dell'autorizzazione per invocare il servizio Anthropic nell'area di lavoro. Controllare il ruolo collegato al profilo AWS o al runner che ha avviato Claude Code e verificare che disponga delle azioni `aws-external-anthropic` documentate nel [riferimento delle azioni IAM](https://platform.claude.com/docs/en/api/claude-platform-on-aws-iam-actions).

325

326Se è stato impostato `ANTHROPIC_AWS_API_KEY`, la chiave ha la precedenza su SigV4 e una chiave obsoleta produce lo stesso errore. Rigenerare la chiave nella console AWS in **Claude Platform on AWS → API keys** o annullare l'impostazione della variabile per tornare alle credenziali AWS.

327

328### Le richieste non riescono con un errore di area di lavoro mancante

329

330`ANTHROPIC_AWS_WORKSPACE_ID` è probabilmente non impostato o vuoto. Ogni richiesta di Claude Platform on AWS deve includere l'ID dell'area di lavoro. Non è implicito dalle credenziali AWS. Trovare l'ID in **Workspaces** nella pagina del servizio della console AWS ed esportarlo prima di avviare Claude Code.

331

332### Le richieste vanno ancora a `api.anthropic.com`

333

334`CLAUDE_CODE_USE_ANTHROPIC_AWS` è probabilmente non impostato o impostato su un valore che non viene analizzato come veritiero. Impostarlo su `1` ed eseguire `/status` per confermare il provider risolto. Se è impostato anche `CLAUDE_CODE_USE_BEDROCK` o `CLAUDE_CODE_USE_FOUNDRY`, questi hanno la precedenza su Claude Platform on AWS.

335

336## Risorse aggiuntive

337

338La sottoscrizione a Claude Platform on AWS, la configurazione dell'area di lavoro e IAM che precede la configurazione di Claude Code è coperta nella documentazione della piattaforma:

339

340* [Panoramica di Claude Platform on AWS](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws): sottoscrizione, configurazione dell'area di lavoro e riferimento del prodotto

341* [Riferimento delle azioni IAM](https://platform.claude.com/docs/en/api/claude-platform-on-aws-iam-actions): autorizzazioni e criteri gestiti

cli-reference.md +7 −1

Details

24| `claude auth login` | Accedi al tuo account Anthropic. Usa `--email` per pre-compilare il tuo indirizzo email, `--sso` per forzare l'autenticazione SSO e `--console` per accedere con Anthropic Console per la fatturazione dell'utilizzo dell'API invece di un abbonamento Claude | `claude auth login --console` |24| `claude auth login` | Accedi al tuo account Anthropic. Usa `--email` per pre-compilare il tuo indirizzo email, `--sso` per forzare l'autenticazione SSO e `--console` per accedere con Anthropic Console per la fatturazione dell'utilizzo dell'API invece di un abbonamento Claude | `claude auth login --console` |

26| `claude auth status` | Mostra lo stato di autenticazione come JSON. Usa `--text` per output leggibile dall'uomo. Esce con codice 0 se connesso, 1 se no | `claude auth status` |26| `claude auth status` | Mostra lo stato di autenticazione come JSON. Usa `--text` per output leggibile dall'uomo. Esce con codice 0 se connesso, 1 se no | `claude auth status` |

27| `claude agents` | Elenca tutti i [subagents](/it/sub-agents) configurati, raggruppati per fonte | `claude agents` |27| `claude agents` | Apri la [visualizzazione agente](/it/agent-view) per monitorare e inviare sessioni parallele in background. Quando l'output viene inviato tramite pipe, elenca invece gli [subagents](/it/sub-agents) configurati | `claude agents` |

28| `claude attach <id>` | Collegati a una [sessione in background](/it/agent-view#manage-sessions-from-the-shell) in questo terminale | `claude attach 7c5dcf5d` |

28| `claude auto-mode defaults` | Stampa le regole del classificatore [auto mode](/it/permission-modes#eliminate-prompts-with-auto-mode) integrate come JSON. Usa `claude auto-mode config` per visualizzare la tua configurazione effettiva con le impostazioni applicate | `claude auto-mode defaults > rules.json` |29| `claude auto-mode defaults` | Stampa le regole del classificatore [auto mode](/it/permission-modes#eliminate-prompts-with-auto-mode) integrate come JSON. Usa `claude auto-mode config` per visualizzare la tua configurazione effettiva con le impostazioni applicate | `claude auto-mode defaults > rules.json` |

30| `claude logs <id>` | Stampa l'output recente da una [sessione in background](/it/agent-view#manage-sessions-from-the-shell) | `claude logs 7c5dcf5d` |

30| `claude plugin` | Gestisci i [plugins](/it/plugins) di Claude Code. Alias: `claude plugins`. Vedi il [riferimento plugin](/it/plugins-reference#cli-commands-reference) per i sottocomandi | `claude plugin install code-review@claude-plugins-official` |32| `claude plugin` | Gestisci i [plugins](/it/plugins) di Claude Code. Alias: `claude plugins`. Vedi il [riferimento plugin](/it/plugins-reference#cli-commands-reference) per i sottocomandi | `claude plugin install code-review@claude-plugins-official` |

31| `claude project purge [path]` | Elimina tutto lo stato locale di Claude Code per un progetto: trascrizioni, elenchi di attività, log di debug, cronologia delle modifiche ai file, righe della cronologia dei prompt e la voce del progetto in `~/.claude.json`. Ometti `[path]` per scegliere da un elenco interattivo. Flag: `--dry-run` per visualizzare un'anteprima, `-y`/`--yes` per saltare la conferma, `-i`/`--interactive` per confermare ogni elemento, `--all` per ogni progetto. Vedi [Cancella dati locali](/it/claude-directory#clear-local-data) | `claude project purge ~/work/repo --dry-run` |33| `claude project purge [path]` | Elimina tutto lo stato locale di Claude Code per un progetto: trascrizioni, elenchi di attività, log di debug, cronologia delle modifiche ai file, righe della cronologia dei prompt e la voce del progetto in `~/.claude.json`. Ometti `[path]` per scegliere da un elenco interattivo. Flag: `--dry-run` per visualizzare un'anteprima, `-y`/`--yes` per saltare la conferma, `-i`/`--interactive` per confermare ogni elemento, `--all` per ogni progetto. Vedi [Cancella dati locali](/it/claude-directory#clear-local-data) | `claude project purge ~/work/repo --dry-run` |

32| `claude remote-control` | Avvia un server [Remote Control](/it/remote-control) per controllare Claude Code da Claude.ai o dall'app Claude. Viene eseguito in modalità server (nessuna sessione interattiva locale). Vedi [Flag modalità server](/it/remote-control#start-a-remote-control-session) | `claude remote-control --name "My Project"` |34| `claude remote-control` | Avvia un server [Remote Control](/it/remote-control) per controllare Claude Code da Claude.ai o dall'app Claude. Viene eseguito in modalità server (nessuna sessione interattiva locale). Vedi [Flag modalità server](/it/remote-control#start-a-remote-control-session) | `claude remote-control --name "My Project"` |

35| `claude respawn <id>` | Riavvia una [sessione in background](/it/agent-view#manage-sessions-from-the-shell) interrotta mantenendo la sua conversazione intatta. Usa `--all` per riavviare ogni sessione interrotta | `claude respawn 7c5dcf5d` |

36| `claude rm <id>` | Rimuovi una [sessione in background](/it/agent-view#manage-sessions-from-the-shell) dall'elenco | `claude rm 7c5dcf5d` |

33| `claude setup-token` | Genera un token OAuth di lunga durata per CI e script. Stampa il token nel terminale senza salvarlo. Richiede un abbonamento Claude. Vedi [Genera un token di lunga durata](/it/authentication#generate-a-long-lived-token) | `claude setup-token` |37| `claude setup-token` | Genera un token OAuth di lunga durata per CI e script. Stampa il token nel terminale senza salvarlo. Richiede un abbonamento Claude. Vedi [Genera un token di lunga durata](/it/authentication#generate-a-long-lived-token) | `claude setup-token` |

38| `claude stop <id>` | Interrompi una [sessione in background](/it/agent-view#manage-sessions-from-the-shell). Accetta anche `claude kill` | `claude stop 7c5dcf5d` |

34| `claude ultrareview [target]` | Esegui [ultrareview](/it/ultrareview#run-ultrareview-non-interactively) in modo non interattivo. Stampa i risultati su stdout e esce con 0 in caso di successo o 1 in caso di errore. Usa `--json` per il payload grezzo e `--timeout <minutes>` per sovrascrivere il valore predefinito di 30 minuti | `claude ultrareview 1234 --json` |39| `claude ultrareview [target]` | Esegui [ultrareview](/it/ultrareview#run-ultrareview-non-interactively) in modo non interattivo. Stampa i risultati su stdout e esce con 0 in caso di successo o 1 in caso di errore. Usa `--json` per il payload grezzo e `--timeout <minutes>` per sovrascrivere il valore predefinito di 30 minuti | `claude ultrareview 1234 --json` |

35 40

36Se digiti male un sottocomando, Claude Code suggerisce la corrispondenza più vicina e esce senza avviare una sessione. Ad esempio, `claude udpate` stampa `Did you mean claude update?`.41Se digiti male un sottocomando, Claude Code suggerisce la corrispondenza più vicina e esce senza avviare una sessione. Ad esempio, `claude udpate` stampa `Did you mean claude update?`.

50| `--append-system-prompt-file` | Carica testo di prompt di sistema aggiuntivo da un file e aggiungi al prompt predefinito | `claude --append-system-prompt-file ./extra-rules.txt` |55| `--append-system-prompt-file` | Carica testo di prompt di sistema aggiuntivo da un file e aggiungi al prompt predefinito | `claude --append-system-prompt-file ./extra-rules.txt` |

51| `--bare` | Modalità minima: salta l'auto-discovery di hooks, skills, plugins, server MCP, memoria automatica e CLAUDE.md in modo che le chiamate con script si avviino più velocemente. Claude ha accesso a strumenti Bash, lettura file e modifica file. Imposta [`CLAUDE_CODE_SIMPLE`](/it/env-vars). Vedi [modalità bare](/it/headless#start-faster-with-bare-mode) | `claude --bare -p "query"` |56| `--bare` | Modalità minima: salta l'auto-discovery di hooks, skills, plugins, server MCP, memoria automatica e CLAUDE.md in modo che le chiamate con script si avviino più velocemente. Claude ha accesso a strumenti Bash, lettura file e modifica file. Imposta [`CLAUDE_CODE_SIMPLE`](/it/env-vars). Vedi [modalità bare](/it/headless#start-faster-with-bare-mode) | `claude --bare -p "query"` |

58| `--bg` | Avvia la sessione come un [agent in background](/it/agent-view) e ritorna immediatamente. Stampa l'ID della sessione e i comandi di gestione. Combina con `--agent` per eseguire uno specifico subagent | `claude --bg "investigate the flaky test"` |

53| `--channels` | (Anteprima di ricerca) Server MCP le cui notifiche di [channel](/it/channels) Claude dovrebbe ascoltare in questa sessione. Elenco separato da spazi di voci `plugin:<name>@<marketplace>`. Richiede autenticazione Claude.ai | `claude --channels plugin:my-notifier@my-marketplace` |59| `--channels` | (Anteprima di ricerca) Server MCP le cui notifiche di [channel](/it/channels) Claude dovrebbe ascoltare in questa sessione. Elenco separato da spazi di voci `plugin:<name>@<marketplace>`. Richiede autenticazione Claude.ai | `claude --channels plugin:my-notifier@my-marketplace` |

55| `--continue`, `-c` | Carica la conversazione più recente nella directory corrente. Include sessioni che hanno aggiunto questa directory con `/add-dir` | `claude --continue` |61| `--continue`, `-c` | Carica la conversazione più recente nella directory corrente. Include sessioni che hanno aggiunto questa directory con `/add-dir` | `claude --continue` |

commands.md +6 −1

Details

20 20

21**Durante un'attività.** `/plan` passa alla modalità plan prima di una modifica importante. `/model` e `/effort` regolano quanto ragionamento stai spendendo. Quando la conversazione diventa lunga, `/context` mostra dove sta andando la finestra e `/compact` la riassume; usa `/btw` per una rapida considerazione laterale che non dovrebbe gonfiare la cronologia.21**Durante un'attività.** `/plan` passa alla modalità plan prima di una modifica importante. `/model` e `/effort` regolano quanto ragionamento stai spendendo. Quando la conversazione diventa lunga, `/context` mostra dove sta andando la finestra e `/compact` la riassume; usa `/btw` per una rapida considerazione laterale che non dovrebbe gonfiare la cronologia.

22 22

23**Esecuzione del lavoro in parallelo.** `/agents` apre il gestore per i [subagent](/it/sub-agents) a cui Claude può delegare attività secondarie, e `/tasks` elenca cosa è in esecuzione in background della sessione corrente. `/background` scollega l'intera sessione per continuare l'esecuzione come [agente in background](/it/agent-view) e libera il tuo terminale. Per una modifica importante che si estende su tutta la codebase, `/batch` la scompone in unità indipendenti ed esegue ciascuna nel suo proprio [worktree](/it/worktrees). Vedi [Esegui agenti in parallelo](/it/agents) per come questi approcci si relazionano.

23**Prima di inviare.** `/diff` mostra cosa è cambiato, `/simplify` esamina i file recenti e applica correzioni di qualità ed efficienza, e `/review` o `/security-review` forniscono una lettura più profonda in sola lettura.25**Prima di inviare.** `/diff` mostra cosa è cambiato, `/simplify` esamina i file recenti e applica correzioni di qualità ed efficienza, e `/review` o `/security-review` forniscono una lettura più profonda in sola lettura.

24 26

25**Tra le sessioni.** `/clear` inizia da capo su un nuovo compito mantenendo la memoria del progetto. `/resume` e `/branch` ti permettono di tornare a una conversazione precedente o di crearvi un ramo. `/teleport` estrae una sessione web in questo terminale, e `/remote-control` ti permette di continuare questa sessione locale da un altro dispositivo.27**Tra le sessioni.** `/clear` inizia da capo su un nuovo compito mantenendo la memoria del progetto. `/resume` e `/branch` ti permettono di tornare a una conversazione precedente o di crearvi un ramo. `/teleport` estrae una sessione web in questo terminale, e `/remote-control` ti permette di continuare questa sessione locale da un altro dispositivo.

41| `/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` |43| `/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` |

43| `/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) |45| `/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) |

44| `/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` |46| `/background [prompt]` | Stacca la sessione corrente per eseguirla come un [agente in background](/it/agent-view) e libera questo terminale. Passa un prompt per inviare un'istruzione in più prima di staccarsi. Monitora la sessione con `claude agents`. Alias: `/bg` |

47| `/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 [subagent in background](/it/sub-agents#run-subagents-in-foreground-or-background) per unità in un [git worktree](/it/worktrees) isolato. Ogni subagent implementa la sua unità, esegue i test e apre una pull request. Richiede un repository git. Esempio: `/batch migrate src/ from Solid to React` |

45| `/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 |48| `/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 |

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

66| `/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 |69| `/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 |

67| `/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) |70| `/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) |

71| `/goal [condition\|clear]` | Imposta un [obiettivo](/it/goal): Claude continua a lavorare tra i turni finché la condizione non è soddisfatta. Senza un argomento, mostra l'obiettivo corrente o raggiunto più di recente. `clear`, `stop`, `off`, `reset`, `none` o `cancel` rimuove un obiettivo attivo in anticipo |

68| `/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) |72| `/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) |

109| `/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 |113| `/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 |

110| `/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 |114| `/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 |

116| `/stop` | Ferma la [sessione in background](/it/agent-view) corrente. Disponibile solo quando collegato a una sessione in background; la trascrizione e qualsiasi worktree vengono conservati. Per staccarsi senza fermare, usa `/exit` o premi `←` |

113| `/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 |118| `/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 |

114| `/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 |119| `/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 |

common-workflows.md +85 −589

Details

6 6

7> Guide passo dopo passo per esplorare basi di codice, correggere bug, effettuare refactoring, testare e altri compiti quotidiani con Claude Code.7> Guide passo dopo passo per esplorare basi di codice, correggere bug, effettuare refactoring, testare e altri compiti quotidiani con Claude Code.

8 8

9Questa pagina copre flussi di lavoro pratici per lo sviluppo quotidiano: esplorare codice non familiare, eseguire il debug, effettuare refactoring, scrivere test, creare PR e gestire sessioni. Ogni sezione include prompt di esempio che puoi adattare ai tuoi progetti. Per modelli e suggerimenti di livello superiore, vedi [Best practices](/it/best-practices).9Questa pagina raccoglie brevi ricette per lo sviluppo quotidiano. Per una guida di livello superiore sulla formulazione di prompt e la gestione del contesto, vedi [Best practices](/it/best-practices).

10 10

~~11## Comprendere nuove basi di codice~~11Questa pagina copre:

12 12

~~13### Ottenere una rapida panoramica della base di codice~~13* [Ricette di prompt](#prompt-recipes) per esplorare il codice, correggere bug, effettuare refactoring, testare, PR e documentazione

14* [Riprendere conversazioni precedenti](#resume-previous-conversations) in modo che un'attività possa durare più sessioni

15* [Eseguire sessioni parallele con worktrees](#run-parallel-sessions-with-worktrees) in modo che le modifiche simultanee non si scontrino

16* [Pianificare prima di modificare](#plan-before-editing) per rivedere le modifiche prima che tocchino il disco

17* [Delegare la ricerca ai subagent](#delegate-research-to-subagents) per mantenere il tuo contesto principale pulito

18* [Inviare Claude negli script](#pipe-claude-into-scripts) per CI e elaborazione batch

20## Ricette di prompt

22Questi sono modelli di prompt per compiti quotidiani come esplorare codice non familiare, eseguire il debug, effettuare refactoring, scrivere test e creare PR. Ognuno funziona su qualsiasi superficie di Claude Code; adatta la formulazione al tuo progetto.

24### Comprendere nuove basi di codice

26#### Ottenere una rapida panoramica della base di codice

14 27

15Supponiamo che tu abbia appena aderito a un nuovo progetto e debba comprendere rapidamente la sua struttura.28Supponiamo che tu abbia appena aderito a un nuovo progetto e debba comprendere rapidamente la sua struttura.

16 29

56 * Richiedi un glossario di termini specifici del progetto69 * Richiedi un glossario di termini specifici del progetto

57</Tip>70</Tip>

58 71

~~59### Trovare codice rilevante~~72#### Trovare codice rilevante

60 73

61Supponiamo che tu debba individuare il codice relativo a una funzionalità o funzione specifica.74Supponiamo che tu debba individuare il codice relativo a una funzionalità o funzione specifica.

62 75

90 103

91***104***

92 105

~~93## Correggere bug in modo efficiente~~106### Correggere bug in modo efficiente

94 107

95Supponiamo che tu abbia riscontrato un messaggio di errore e debba trovare e correggere la sua fonte.108Supponiamo che tu abbia riscontrato un messaggio di errore e debba trovare e correggere la sua fonte.

96 109

124 137

125***138***

126 139

127## Effettuare refactoring del codice140### Effettuare refactoring del codice

128 141

129Supponiamo che tu debba aggiornare il codice precedente per utilizzare modelli e pratiche moderne.142Supponiamo che tu debba aggiornare il codice precedente per utilizzare modelli e pratiche moderne.

130 143

164 177

165***178***

166 179

167## Utilizzare subagent specializzati180### Lavorare con i test

~~168~~

169Supponiamo che tu voglia utilizzare subagent AI specializzati per gestire attività specifiche in modo più efficace.

~~170~~

171<Steps>

172 <Step title="Visualizzare i subagent disponibili">

173 ```text theme={null}

174 /agents

175 ```

~~176~~

177 Questo mostra tutti i subagent disponibili e ti consente di crearne di nuovi.

178 </Step>

~~179~~

180 <Step title="Utilizzare i subagent automaticamente">

181 Claude Code delega automaticamente le attività appropriate ai subagent specializzati:

~~182~~

183 ```text theme={null}

184 review my recent code changes for security issues

185 ```

~~186~~

187 ```text theme={null}

188 run all tests and fix any failures

189 ```

190 </Step>

~~191~~

192 <Step title="Richiedere esplicitamente subagent specifici">

193 ```text theme={null}

194 use the code-reviewer subagent to check the auth module

195 ```

~~196~~

197 ```text theme={null}

198 have the debugger subagent investigate why users can't log in

199 ```

200 </Step>

~~201~~

202 <Step title="Creare subagent personalizzati per il tuo flusso di lavoro">

203 ```text theme={null}

204 /agents

205 ```

~~206~~

207 Quindi seleziona "Create New subagent" e segui i prompt per definire:

~~208~~

209 * Un identificatore univoco che descrive lo scopo del subagent (ad esempio, `code-reviewer`, `api-designer`).

210 * Quando Claude dovrebbe utilizzare questo agente

211 * Quali strumenti può accedere

212 * Un prompt di sistema che descrive il ruolo e il comportamento dell'agente

213 </Step>

214</Steps>

~~215~~

216<Tip>

217 Suggerimenti:

~~218~~

219 * Crea subagent specifici del progetto in `.claude/agents/` per la condivisione del team

220 * Usa campi `description` descrittivi per abilitare la delegazione automatica

221 * Limita l'accesso agli strumenti a ciò di cui ogni subagent ha effettivamente bisogno

222 * Controlla la [documentazione dei subagent](/it/sub-agents) per esempi dettagliati

223</Tip>

~~224~~

225***

~~226~~

227## Utilizzare Plan Mode per l'analisi sicura del codice

~~228~~

229Plan Mode istruisce Claude a creare un piano analizzando la base di codice con operazioni di sola lettura, perfetto per esplorare basi di codice, pianificare modifiche complesse o rivedere il codice in modo sicuro. In Plan Mode, Claude utilizza [`AskUserQuestion`](/it/tools-reference) per raccogliere requisiti e chiarire i tuoi obiettivi prima di proporre un piano.

~~230~~

231### Quando utilizzare Plan Mode

~~232~~

233* **Implementazione multi-step**: Quando la tua funzionalità richiede di apportare modifiche a molti file

234* **Esplorazione del codice**: Quando desideri ricercare a fondo la base di codice prima di modificare qualsiasi cosa

235* **Sviluppo interattivo**: Quando desideri iterare sulla direzione con Claude

~~236~~

237### Come utilizzare Plan Mode

~~238~~

239**Attivare Plan Mode durante una sessione**

~~240~~

241Puoi passare a Plan Mode durante una sessione utilizzando **Shift+Tab** per scorrere le modalità di autorizzazione.

~~242~~

243Se sei in Normal Mode, **Shift+Tab** passa prima a Auto-Accept Mode, indicato da `⏵⏵ accept edits on` nella parte inferiore del terminale. Un successivo **Shift+Tab** passerà a Plan Mode, indicato da `⏸ plan mode on`.

~~244~~

245**Avviare una nuova sessione in Plan Mode**

~~246~~

247Per avviare una nuova sessione in Plan Mode, usa il flag `--permission-mode plan`:

~~248~~

249```bash theme={null}

250claude --permission-mode plan

251```

~~252~~

253**Eseguire query "headless" in Plan Mode**

~~254~~

255Puoi anche eseguire una query in Plan Mode direttamente con `-p` (cioè in ["headless mode"](/it/headless)):

~~256~~

257```bash theme={null}

258claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

259```

~~260~~

261### Esempio: Pianificazione di un refactoring complesso

~~262~~

263```bash theme={null}

264claude --permission-mode plan

265```

~~266~~

267```text theme={null}

268I need to refactor our authentication system to use OAuth2. Create a detailed migration plan.

269```

~~270~~

271Claude analizza l'implementazione attuale e crea un piano completo. Affina con follow-up:

~~272~~

273```text theme={null}

274What about backward compatibility?

275```

~~276~~

277```text theme={null}

278How should we handle database migration?

279```

~~280~~

281<Tip>Premi `Ctrl+G` per aprire il piano nel tuo editor di testo predefinito, dove puoi modificarlo direttamente prima che Claude proceda.</Tip>

~~282~~

283Quando accetti un piano, Claude denomina automaticamente la sessione dal contenuto del piano. Il nome appare sulla barra del prompt e nel selettore di sessione. Se hai già impostato un nome con `--name` o `/rename`, accettare un piano non lo sovrascriverà.

~~284~~

285### Configurare Plan Mode come predefinito

~~286~~

287```json theme={null}

288// .claude/settings.json

289{

290 "permissions": {

291 "defaultMode": "plan"

292 }

293}

294```

~~295~~

296Vedi la [documentazione delle impostazioni](/it/settings#available-settings) per ulteriori opzioni di configurazione.

~~297~~

298***

~~299~~

300## Lavorare con i test

301 181

302Supponiamo che tu debba aggiungere test per il codice non coperto.182Supponiamo che tu debba aggiungere test per il codice non coperto.

303 183

333 213

334***214***

335 215

336## Creare pull request216### Creare pull request

337 217

338Puoi creare pull request chiedendo direttamente a Claude ("create a pr for my changes"), oppure guidare Claude attraverso i passaggi:218Puoi creare pull request chiedendo direttamente a Claude ("create a pr for my changes"), oppure guidare Claude attraverso i passaggi:

339 219

357 </Step>237 </Step>

358</Steps>238</Steps>

359 239

360Quando crei una PR utilizzando `gh pr create`, la sessione viene automaticamente collegata a quella PR. Puoi riprenderla in seguito con `claude --from-pr <number>`.240Quando crei una PR utilizzando `gh pr create`, la sessione viene automaticamente collegata a quella PR. Per tornare a essa in seguito, esegui `claude --from-pr <number>` o incolla l'URL della PR nel selettore [`/resume`](/it/sessions#use-the-session-picker).

361 241

362<Tip>242<Tip>

363 Rivedi la PR generata da Claude prima di inviarla e chiedi a Claude di evidenziare i rischi potenziali o le considerazioni.243 Rivedi la PR generata da Claude prima di inviarla e chiedi a Claude di evidenziare i rischi potenziali o le considerazioni.

364</Tip>244</Tip>

365 245

366## Gestire la documentazione246### Gestire la documentazione

367 247

368Supponiamo che tu debba aggiungere o aggiornare la documentazione per il tuo codice.248Supponiamo che tu debba aggiungere o aggiornare la documentazione per il tuo codice.

369 249

403 283

404***284***

405 285

406## Lavorare in note e cartelle non di codice286### Lavorare in note e cartelle non di codice

407 287

408Claude Code funziona in qualsiasi directory. Eseguilo all'interno di un vault di note, una cartella di documentazione o qualsiasi raccolta di file markdown per cercare, modificare e riorganizzare il contenuto nello stesso modo in cui faresti con il codice.288Claude Code funziona in qualsiasi directory. Eseguilo all'interno di un vault di note, una cartella di documentazione o qualsiasi raccolta di file markdown per cercare, modificare e riorganizzare il contenuto nello stesso modo in cui faresti con il codice.

409 289

411 291

412***292***

413 293

414## Lavorare con le immagini294### Lavorare con le immagini

415 295

416Supponiamo che tu debba lavorare con immagini nella tua base di codice e desideri l'aiuto di Claude nell'analizzare il contenuto dell'immagine.296Supponiamo che tu debba lavorare con immagini nella tua base di codice e desideri l'aiuto di Claude nell'analizzare il contenuto dell'immagine.

417 297

471 351

472***352***

473 353

474## Fare riferimento a file e directory354### Fare riferimento a file e directory

475 355

476Usa @ per includere rapidamente file o directory senza aspettare che Claude li legga.356Usa @ per includere rapidamente file o directory senza aspettare che Claude li legga.

477 357

512 392

513***393***

514 394

515## Utilizzare il pensiero esteso (Thinking Mode)395### Eseguire Claude su una pianificazione

~~516~~

517[Extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) è abilitato per impostazione predefinita, dando a Claude lo spazio per ragionare attraverso problemi complessi passo dopo passo prima di rispondere. Questo ragionamento è visibile in modalità verbose, che puoi attivare con `Ctrl+O`. Durante il pensiero esteso, lo spinner mostra suggerimenti di progresso inline come "still thinking" e "almost done thinking" per indicare che Claude sta lavorando attivamente.

~~518~~

519Inoltre, i [modelli che supportano lo sforzo](/it/model-config#adjust-effort-level) utilizzano il ragionamento adattivo: invece di un budget di token di pensiero fisso, il modello decide dinamicamente se e quanto pensare in base alla tua impostazione di livello di sforzo e al compito in questione. Il ragionamento adattivo consente a Claude di rispondere più velocemente ai prompt di routine e di riservare un pensiero più profondo ai passaggi che ne traggono beneficio.

~~520~~

521Extended thinking è particolarmente prezioso per decisioni architettoniche complesse, bug impegnativi, pianificazione dell'implementazione multi-step e valutazione dei compromessi tra diversi approcci.

~~522~~

523<Note>

524 Frasi come "think", "think hard" e "think more" sono interpretate come istruzioni di prompt regolari e non allocano token di pensiero.

525</Note>

~~526~~

527### Configurare Thinking Mode

~~528~~

529Il pensiero è abilitato per impostazione predefinita, ma puoi regolarlo o disabilitarlo.

~~530~~

531| Ambito | Come configurare | Dettagli |

532| --------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

533| **Livello di sforzo** | Esegui `/effort`, regola in `/model`, o imposta [`CLAUDE_CODE_EFFORT_LEVEL`](/it/env-vars) | Controlla la profondità del pensiero su [modelli supportati](/it/model-config#adjust-effort-level) |

534| **Parola chiave `ultrathink`** | Includi "ultrathink" in qualsiasi punto del tuo prompt | Aggiunge un'istruzione in-context che dice al modello di ragionare di più su quel turno. Non cambia il livello di sforzo stesso; vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) per questo |

535| **Scorciatoia di attivazione/disattivazione** | Premi `Option+T` (macOS) o `Alt+T` (Windows/Linux) | Attiva/disattiva il pensiero per la sessione corrente (tutti i modelli). Potrebbe richiedere la [configurazione del terminale](/it/terminal-config) per abilitare le scorciatoie da tastiera Option |

536| **Predefinito globale** | Usa `/config` per attivare/disattivare Thinking Mode | Imposta il tuo predefinito in tutti i progetti (tutti i modelli).<br />Salvato come `alwaysThinkingEnabled` in `~/.claude/settings.json` |

537| **Limitare il budget dei token** | Imposta la variabile di ambiente [`MAX_THINKING_TOKENS`](/it/env-vars) | Limita il budget di pensiero a un numero specifico di token. Su modelli con ragionamento adattivo, solo `0` si applica a meno che il ragionamento adattivo non sia disabilitato. Esempio: `export MAX_THINKING_TOKENS=10000` |

~~538~~

539Per visualizzare il processo di pensiero di Claude, premi `Ctrl+O` per attivare la modalità verbose e vedi il ragionamento interno visualizzato come testo grigio in corsivo.

~~540~~

541### Come funziona il pensiero esteso

~~542~~

543Extended thinking controlla quanto ragionamento interno Claude esegue prima di rispondere. Più pensiero fornisce più spazio per esplorare soluzioni, analizzare casi limite e autocorreggersi gli errori.

~~544~~

545Su [modelli che supportano lo sforzo](/it/model-config#adjust-effort-level), il pensiero utilizza il ragionamento adattivo: il modello alloca dinamicamente i token di pensiero in base al livello di sforzo che selezioni. Questo è il modo consigliato per sintonizzare il compromesso tra velocità e profondità di ragionamento. Se desideri che Claude pensi più o meno spesso di quanto il tuo livello di sforzo produrrebbe altrimenti, puoi anche dirlo direttamente nel tuo prompt o in `CLAUDE.md`.

~~546~~

547Con modelli più vecchi, il pensiero utilizza un budget fisso di token prelevato dalla tua allocazione di output. Il budget varia in base al modello; vedi [`MAX_THINKING_TOKENS`](/it/env-vars) per i massimali per modello. Puoi limitare il budget con quella variabile di ambiente, o disabilitare completamente il pensiero tramite `/config` o l'attivazione/disattivazione `Option+T`/`Alt+T`.

~~548~~

549Su modelli con ragionamento adattivo, `MAX_THINKING_TOKENS` si applica solo quando impostato su `0` per disabilitare il pensiero, o quando `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` ripristina il modello al budget fisso. `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` si applica solo a Opus 4.6 e Sonnet 4.6. Opus 4.7 utilizza sempre il ragionamento adattivo e non supporta un budget di pensiero fisso. Vedi [variabili di ambiente](/it/env-vars).

~~550~~

551<Warning>

552 Ti viene addebitato per tutti i token di pensiero utilizzati anche quando i riassunti di pensiero sono redatti. In modalità interattiva, il pensiero appare come uno stub compresso per impostazione predefinita. Imposta `showThinkingSummaries: true` in `settings.json` per mostrare riassunti completi.

553</Warning>

~~554~~

555***

~~556~~

557## Riprendere conversazioni precedenti

~~558~~

559Quando avvii Claude Code, puoi riprendere una sessione precedente:

~~560~~

561* `claude --continue` continua la conversazione più recente nella directory corrente

562* `claude --resume` apre un selettore di conversazione o riprende per nome

563* `claude --from-pr 123` riprende le sessioni collegate a una pull request specifica

~~564~~

565Da una sessione attiva, usa `/resume` per passare a una conversazione diversa.

~~566~~

567Quando la sessione selezionata è vecchia e abbastanza grande che rileggere la richiederebbe una quota sostanziale dei tuoi limiti di utilizzo, `--resume`, `--continue` e `/resume` offrono di riprendere da un riassunto invece di caricare la trascrizione completa. Questo prompt non è disponibile su Amazon Bedrock, Google Cloud Vertex AI o Microsoft Foundry.

~~568~~

569Le sessioni vengono archiviate per directory di progetto. Per impostazione predefinita, il selettore `/resume` mostra le sessioni interattive dal worktree corrente, con scorciatoie da tastiera per ampliare l'elenco ad altri worktree o progetti, cercare, visualizzare l'anteprima e rinominare. Vedi [Utilizzare il selettore di sessione](#use-the-session-picker) di seguito per il riferimento completo delle scorciatoie.

~~570~~

571Quando selezioni una sessione da un altro worktree dello stesso repository, Claude Code la riprende direttamente senza richiedere di cambiare directory prima. Selezionare una sessione da un progetto non correlato copia un comando `cd` e resume negli appunti.

~~572~~

573La ripresa per nome si risolve nel repository corrente e nei suoi worktree. Sia `claude --resume <name>` che `/resume <name>` cercano una corrispondenza esatta e la riprendono direttamente, anche se la sessione si trova in un worktree diverso.

~~574~~

575Quando il nome è ambiguo, `claude --resume <name>` apre il selettore con il nome pre-compilato come termine di ricerca. `/resume <name>` da una sessione attiva segnala un errore, quindi esegui `/resume` senza argomenti per aprire il selettore e scegliere.

~~576~~

577Le sessioni create da `claude -p` o da invocazioni SDK non appaiono nel selettore, ma puoi comunque riprenderne una passando il suo ID di sessione direttamente a `claude --resume <session-id>`.

~~578~~

579### Denominare le tue sessioni

~~580~~

581Dai alle sessioni nomi descrittivi per trovarle in seguito. Questa è una best practice quando lavori su più attività o funzionalità.

~~582~~

583<Steps>

584 <Step title="Denominare la sessione">

585 Denomina una sessione all'avvio con `-n`:

~~586~~

587 ```bash theme={null}

588 claude -n auth-refactor

589 ```

~~590~~

591 Oppure usa `/rename` durante una sessione, che mostra anche il nome sulla barra del prompt:

~~592~~

593 ```text theme={null}

594 /rename auth-refactor

595 ```

~~596~~

597 Puoi anche rinominare qualsiasi sessione dal selettore: esegui `/resume`, naviga a una sessione e premi `Ctrl+R`.

598 </Step>

~~599~~

600 <Step title="Riprendere per nome in seguito">

601 Dalla riga di comando:

~~602~~

603 ```bash theme={null}

604 claude --resume auth-refactor

605 ```

~~606~~

607 O da una sessione attiva:

~~608~~

609 ```text theme={null}

610 /resume auth-refactor

611 ```

612 </Step>

613</Steps>

~~614~~

615### Utilizzare il selettore di sessione

~~616~~

617Il comando `/resume` (o `claude --resume` senza argomenti) apre un selettore di sessione interattivo con queste funzionalità:

~~618~~

619**Scorciatoie da tastiera nel selettore:**

~~620~~

621| Scorciatoia | Azione |

622| :------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

623| `↑` / `↓` | Navigare tra le sessioni |

624| `→` / `←` | Espandere o comprimere le sessioni raggruppate |

625| `Enter` | Selezionare e riprendere la sessione evidenziata |

626| `Space` | Visualizzare l'anteprima del contenuto della sessione. `Ctrl+V` funziona anche su terminali che non lo catturano come incolla |

627| `Ctrl+R` | Rinominare la sessione evidenziata |

628| `/` o qualsiasi carattere stampabile diverso da `Space` | Entrare in modalità di ricerca e filtrare le sessioni |

629| `Ctrl+A` | Mostrare le sessioni da tutti i progetti su questa macchina. Premi di nuovo per ripristinare il repository corrente |

630| `Ctrl+W` | Mostrare le sessioni da tutti i worktree del repository corrente. Premi di nuovo per ripristinare il worktree corrente. Mostrato solo in repository con più worktree |

631| `Ctrl+B` | Filtrare le sessioni dal tuo ramo git corrente. Premi di nuovo per mostrare le sessioni da tutti i rami |

632| `Esc` | Uscire dal selettore o dalla modalità di ricerca |

~~633~~

634**Organizzazione della sessione:**

~~635~~

636Il selettore visualizza le sessioni con metadati utili:

~~637~~

638* Nome della sessione se impostato, altrimenti il riassunto della conversazione o il primo prompt dell'utente

639* Tempo trascorso dall'ultima attività

640* Conteggio dei messaggi

641* Ramo Git (se applicabile)

642* Percorso del progetto, mostrato dopo l'ampliamento a tutti i progetti con `Ctrl+A`

~~643~~

644Le sessioni fork (create con `/branch`, `/rewind`, o `--fork-session`) sono raggruppate insieme sotto la loro sessione radice, rendendo più facile trovare conversazioni correlate.

~~645~~

646<Tip>

647 Suggerimenti:

~~648~~

649 * **Denominare le sessioni in anticipo**: Usa `/rename` quando inizi a lavorare su un'attività distinta: è molto più facile trovare "payment-integration" che "explain this function" in seguito

650 * Usa `--continue` per un accesso rapido alla tua conversazione più recente nella directory corrente

651 * Usa `--resume session-name` quando sai quale sessione ti serve

652 * Usa `--resume` (senza un nome) quando hai bisogno di sfogliare e selezionare

653 * Per gli script, usa `claude --continue --print "prompt"` per riprendere in modalità non interattiva

654 * Premi `Space` nel selettore per visualizzare l'anteprima di una sessione prima di riprenderla

655 * La conversazione ripresa inizia con lo stesso modello e configurazione dell'originale

~~656~~

657 Come funziona:

~~658~~

659 1. **Archiviazione della conversazione**: Tutte le conversazioni vengono salvate automaticamente localmente con la loro cronologia completa dei messaggi

660 2. **Deserializzazione dei messaggi**: Quando si riprende, l'intera cronologia dei messaggi viene ripristinata per mantenere il contesto

661 3. **Stato dello strumento**: L'utilizzo dello strumento e i risultati della conversazione precedente vengono preservati

662 4. **Ripristino del contesto**: La conversazione riprende con tutto il contesto precedente intatto

663</Tip>

~~664~~

665***

~~666~~

667## Eseguire sessioni parallele di Claude Code con Git worktrees

~~668~~

669Quando lavori su più attività contemporaneamente, hai bisogno che ogni sessione di Claude abbia la sua copia della base di codice in modo che le modifiche non si scontrino. I worktree Git risolvono questo creando directory di lavoro separate che hanno ciascuna i propri file e ramo, mentre condividono la stessa cronologia del repository e le connessioni remote. Ciò significa che puoi avere Claude che lavora su una funzionalità in un worktree mentre corregge un bug in un altro, senza che nessuna sessione interferisca con l'altra.

~~670~~

671Usa il flag `--worktree` (`-w`) per creare un worktree isolato e avviare Claude in esso. Il valore che passi diventa il nome della directory del worktree e il nome del ramo:

~~672~~

673```bash theme={null}

674# Avviare Claude in un worktree denominato "feature-auth"

675# Crea .claude/worktrees/feature-auth/ con un nuovo ramo

676claude --worktree feature-auth

~~677~~

678# Avviare un'altra sessione in un worktree separato

679claude --worktree bugfix-123

680```

~~681~~

682Se ometti il nome, Claude ne genera uno casuale automaticamente:

~~683~~

684```bash theme={null}

685# Genera automaticamente un nome come "bright-running-fox"

686claude --worktree

687```

~~688~~

689I worktree vengono creati in `<repo>/.claude/worktrees/<name>` e si diramano dal ramo remoto predefinito, che è dove `origin/HEAD` punta. Il ramo del worktree è denominato `worktree-<name>`.

~~690~~

691Il ramo di base non è configurabile tramite un flag o un'impostazione di Claude Code. `origin/HEAD` è un riferimento archiviato nella tua directory `.git` locale che Git ha impostato una volta quando hai clonato. Se il ramo predefinito del repository cambia successivamente su GitHub o GitLab, il tuo `origin/HEAD` locale continua a puntare a quello vecchio, e i worktree si diramano da lì. Per risincronizzare il tuo riferimento locale con quello che il remoto considera attualmente il suo predefinito:

~~692~~

693```bash theme={null}

694git remote set-head origin -a

695```

~~696~~

697Questo è un comando Git standard che aggiorna solo la tua directory `.git` locale. Nulla sul server remoto cambia. Se desideri che i worktree si basino su un ramo specifico piuttosto che sul predefinito del remoto, impostalo esplicitamente con `git remote set-head origin your-branch-name`.

~~698~~

699Per il controllo completo su come vengono creati i worktree, inclusa la scelta di una base diversa per invocazione, configura un [hook WorktreeCreate](/it/hooks#worktreecreate). L'hook sostituisce completamente la logica predefinita di `git worktree` di Claude Code, quindi puoi recuperare e diramati da qualsiasi ref di cui hai bisogno.

~~700~~

701Puoi anche chiedere a Claude di "work in a worktree" o "start a worktree" durante una sessione, e creerà uno automaticamente.

~~702~~

703### Worktree dei subagent

~~704~~

705I subagent possono anche utilizzare l'isolamento del worktree per lavorare in parallelo senza conflitti. Chiedi a Claude di "use worktrees for your agents" o configuralo in un [subagent personalizzato](/it/sub-agents#supported-frontmatter-fields) aggiungendo `isolation: worktree` al frontmatter dell'agente. Ogni subagent ottiene il suo worktree che viene automaticamente pulito quando il subagent finisce senza modifiche.

~~706~~

707### Pulizia del worktree

~~708~~

709Quando esci da una sessione di worktree, Claude gestisce la pulizia in base al fatto che tu abbia apportato modifiche:

~~710~~

711* **Nessuna modifica**: il worktree e il suo ramo vengono rimossi automaticamente

712* **Modifiche o commit esistenti**: Claude ti chiede se mantenere o rimuovere il worktree. Mantenere preserva la directory e il ramo in modo da poter tornare in seguito. Rimuovere elimina la directory del worktree e il suo ramo, scartando tutte le modifiche non sottoposte a commit e i commit

~~713~~

714I worktree dei subagent orfani da un crash o da un'esecuzione parallela interrotta vengono rimossi automaticamente all'avvio una volta che sono più vecchi della tua impostazione [`cleanupPeriodDays`](/it/settings#available-settings), a condizione che non abbiano modifiche non sottoposte a commit, nessun file non tracciato e nessun commit non sottoposto a push. I worktree che crei con `--worktree` non vengono mai rimossi da questa pulizia.

~~715~~

716Per pulire i worktree al di fuori di una sessione di Claude, usa la [gestione manuale del worktree](#manage-worktrees-manually).

~~717~~

718<Tip>

719 Aggiungi `.claude/worktrees/` al tuo `.gitignore` per evitare che il contenuto del worktree appaia come file non tracciati nel tuo repository principale.

720</Tip>

~~721~~

722### Copiare file ignorati da git nei worktree

~~723~~

724I worktree Git sono checkout freschi, quindi non includono file non tracciati come `.env` o `.env.local` dal tuo repository principale. Per copiare automaticamente questi file quando Claude crea un worktree, aggiungi un file `.worktreeinclude` alla radice del tuo progetto.

~~725~~

726Il file utilizza la sintassi `.gitignore` per elencare quali file copiare. Solo i file che corrispondono a un modello e sono anche ignorati da git vengono copiati, quindi i file tracciati non vengono mai duplicati.

~~727~~

728```text .worktreeinclude theme={null}

729.env

730.env.local

731config/secrets.json

732```

~~733~~

734Questo si applica ai worktree creati con `--worktree`, ai worktree dei subagent e alle sessioni parallele nell'[app desktop](/it/desktop#work-in-parallel-with-sessions).

~~735~~

736### Gestire i worktree manualmente

~~737~~

738Per un maggiore controllo sulla posizione del worktree e sulla configurazione del ramo, crea i worktree direttamente con Git. Questo è utile quando hai bisogno di controllare un ramo esistente specifico o posizionare il worktree al di fuori del repository.

~~739~~

740```bash theme={null}

741# Creare un worktree con un nuovo ramo

742git worktree add ../project-feature-a -b feature-a

~~743~~

744# Creare un worktree con un ramo esistente

745git worktree add ../project-bugfix bugfix-123

~~746~~

747# Avviare Claude nel worktree

748cd ../project-feature-a && claude

~~749~~

750# Pulire al termine

751git worktree list

752git worktree remove ../project-feature-a

753```

~~754~~

755Scopri di più nella [documentazione ufficiale di Git worktree](https://git-scm.com/docs/git-worktree).

~~756~~

757<Tip>

758 Ricorda di inizializzare il tuo ambiente di sviluppo in ogni nuovo worktree secondo la configurazione del tuo progetto. A seconda del tuo stack, questo potrebbe includere l'esecuzione dell'installazione delle dipendenze (`npm install`, `yarn`), la configurazione di ambienti virtuali o il seguire il processo di configurazione standard del tuo progetto.

759</Tip>

~~760~~

761### Controllo della versione non git

~~762~~

763L'isolamento del worktree funziona con git per impostazione predefinita. Per altri sistemi di controllo della versione come SVN, Perforce o Mercurial, configura gli hook [WorktreeCreate e WorktreeRemove](/it/hooks#worktreecreate) per fornire logica personalizzata di creazione e pulizia del worktree. Quando configurati, questi hook sostituiscono il comportamento git predefinito quando usi `--worktree`, quindi [`.worktreeinclude`](#copy-gitignored-files-to-worktrees) non viene elaborato. Copia qualsiasi file di configurazione locale all'interno dello script del tuo hook.

~~764~~

765Per il coordinamento automatizzato di sessioni parallele con attività condivise e messaggistica, vedi [team di agenti](/it/agent-teams).

~~766~~

767***

~~768~~

769## Ricevere notifiche quando Claude ha bisogno della tua attenzione

~~770~~

771Quando avvii un'attività a lunga esecuzione e passi a un'altra finestra, puoi configurare notifiche desktop in modo da sapere quando Claude finisce o ha bisogno del tuo input. Questo utilizza l'evento `Notification` [hook](/it/hooks-guide#get-notified-when-claude-needs-input), che si attiva ogni volta che Claude è in attesa di autorizzazione, inattivo e pronto per un nuovo prompt, o completando l'autenticazione.

~~772~~

773<Steps>

774 <Step title="Aggiungere l'hook alle tue impostazioni">

775 Apri `~/.claude/settings.json` e aggiungi un hook `Notification` che chiama il comando di notifica nativa della tua piattaforma:

~~776~~

777 <Tabs>

778 <Tab title="macOS">

779 ```json theme={null}

780 {

781 "hooks": {

782 "Notification": [

783 {

784 "matcher": "",

785 "hooks": [

786 {

787 "type": "command",

788 "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"

789 }

790 ]

791 }

792 ]

793 }

794 }

795 ```

796 </Tab>

~~797~~

798 <Tab title="Linux">

799 ```json theme={null}

800 {

801 "hooks": {

802 "Notification": [

803 {

804 "matcher": "",

805 "hooks": [

806 {

807 "type": "command",

808 "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"

809 }

810 ]

811 }

812 ]

813 }

814 }

815 ```

816 </Tab>

~~817~~

818 <Tab title="Windows">

819 ```json theme={null}

820 {

821 "hooks": {

822 "Notification": [

823 {

824 "matcher": "",

825 "hooks": [

826 {

827 "type": "command",

828 "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""

829 }

830 ]

831 }

832 ]

833 }

834 }

835 ```

836 </Tab>

837 </Tabs>

~~838~~

839 Se il tuo file di impostazioni ha già una chiave `hooks`, unisci la voce `Notification` in essa piuttosto che sovrascrivere. Puoi anche chiedere a Claude di scrivere l'hook per te descrivendo ciò che desideri nella CLI.

840 </Step>

~~841~~

842 <Step title="Facoltativamente restringere il matcher">

843 Per impostazione predefinita l'hook si attiva su tutti i tipi di notifica. Per attivarsi solo per eventi specifici, imposta il campo `matcher` su uno di questi valori:

~~844~~

845 | Matcher | Si attiva quando |

846 | :--------------------- | :----------------------------------------------------------- |

847 | `permission_prompt` | Claude ha bisogno che tu approvi un utilizzo dello strumento |

848 | `idle_prompt` | Claude ha finito ed è in attesa del tuo prossimo prompt |

849 | `auth_success` | L'autenticazione si completa |

850 | `elicitation_dialog` | Un server MCP apre un modulo di elicitazione |

851 | `elicitation_complete` | Un modulo di elicitazione MCP viene inviato o chiuso |

852 | `elicitation_response` | Una risposta di elicitazione MCP viene inviata al server |

853 </Step>

~~854~~

855 <Step title="Verificare l'hook">

856 Digita `/hooks` e seleziona `Notification` per confermare che l'hook appare. Selezionarlo mostra il comando che verrà eseguito. Per testarlo end-to-end, chiedi a Claude di eseguire un comando che richiede autorizzazione e passa a un'altra finestra, oppure chiedi a Claude di attivare una notifica direttamente.

857 </Step>

858</Steps>

~~859~~

860Per lo schema completo dell'evento e i tipi di notifica, vedi il [riferimento Notification](/it/hooks#notification).

~~861~~

862***

~~863~~

864## Utilizzare Claude come utilità di tipo unix

~~865~~

866### Aggiungere Claude al tuo processo di verifica

~~867~~

868Supponiamo che tu voglia utilizzare Claude Code come linter o revisore del codice.

~~869~~

870**Aggiungere Claude al tuo script di build:**

~~871~~

872```json theme={null}

873// package.json

874{

875 ...

876 "scripts": {

877 ...

878 "lint:claude": "claude -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"

879 }

880}

881```

~~882~~

883<Tip>

884 Suggerimenti:

~~885~~

886 * Usa Claude per la revisione automatica del codice nella tua pipeline CI/CD

887 * Personalizza il prompt per verificare i problemi specifici rilevanti per il tuo progetto

888 * Considera di creare più script per diversi tipi di verifica

889</Tip>

~~890~~

891### Pipe in, pipe out

~~892~~

893Supponiamo che tu voglia inviare dati a Claude e ottenere dati in un formato strutturato.

~~894~~

895**Inviare dati attraverso Claude:**

~~896~~

897```bash theme={null}

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

899```

~~900~~

901<Tip>

902 Suggerimenti:

~~903~~

904 * Usa i pipe per integrare Claude negli script shell esistenti

905 * Combina con altri strumenti Unix per flussi di lavoro potenti

906 * Considera di utilizzare `--output-format` per output strutturato

907</Tip>

~~908~~

909### Controllare il formato di output

~~910~~

911Supponiamo che tu abbia bisogno dell'output di Claude in un formato specifico, specialmente quando integri Claude Code in script o altri strumenti.

~~912~~

913<Steps>

914 <Step title="Utilizzare il formato testo (predefinito)">

915 ```bash theme={null}

916 cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt

917 ```

~~918~~

919 Questo restituisce solo la risposta di testo semplice di Claude (comportamento predefinito).

920 </Step>

~~921~~

922 <Step title="Utilizzare il formato JSON">

923 ```bash theme={null}

924 cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json

925 ```

~~926~~

927 Questo restituisce un array JSON di messaggi con metadati inclusi costo e durata.

928 </Step>

~~929~~

930 <Step title="Utilizzare il formato JSON in streaming">

931 ```bash theme={null}

932 cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json

933 ```

~~934~~

935 Questo restituisce una serie di oggetti JSON in tempo reale mentre Claude elabora la richiesta. Ogni messaggio è un oggetto JSON valido, ma l'intero output non è JSON valido se concatenato.

936 </Step>

937</Steps>

~~938~~

939<Tip>

940 Suggerimenti:

~~941~~

942 * Usa `--output-format text` per integrazioni semplici dove hai solo bisogno della risposta di Claude

943 * Usa `--output-format json` quando hai bisogno del registro completo della conversazione

944 * Usa `--output-format stream-json` per l'output in tempo reale di ogni turno di conversazione

945</Tip>

~~946~~

947***

~~948~~

949## Eseguire Claude su una pianificazione

950 396

951Supponiamo che tu voglia che Claude gestisca un'attività automaticamente su base ricorrente, come rivedere le PR aperte ogni mattina, controllare le dipendenze settimanalmente o verificare i fallimenti di CI durante la notte.397Supponiamo che tu voglia che Claude gestisca un'attività automaticamente su base ricorrente, come rivedere le PR aperte ogni mattina, controllare le dipendenze settimanalmente o verificare i fallimenti di CI durante la notte.

952 398

965 411

966***412***

967 413

968## Chiedere a Claude delle sue capacità414### Chiedere a Claude delle sue capacità

969 415

970Claude ha accesso integrato alla sua documentazione e può rispondere a domande sulle sue stesse funzionalità e limitazioni.416Claude ha accesso integrato alla sua documentazione e può rispondere a domande sulle sue stesse funzionalità e limitazioni.

971 417

972### Domande di esempio418#### Domande di esempio

973 419

974```text theme={null}420```text theme={null}

975can Claude Code create pull requests?421can Claude Code create pull requests?

1009 455

1010***456***

1011 457

458## Riprendere conversazioni precedenti

459

460Quando un'attività dura più sessioni, riprendi da dove hai lasciato invece di rispiegare il contesto. Claude Code salva ogni conversazione localmente.

461

462```bash theme={null}

463claude --continue

464```

465

466Questo riprende la sessione più recente nella directory corrente; se non ce n'è ancora una, stampa `No conversation found to continue` ed esce. Usa `claude --resume` per scegliere da un elenco, o `/resume` da una sessione in esecuzione. Vedi [Gestire le sessioni](/it/sessions) per denominazione, branching e il riferimento completo del selettore.

467

468## Eseguire sessioni parallele con worktrees

469

470Lavora su una funzionalità in un terminale mentre Claude corregge un bug in un altro, senza che le modifiche si scontrino. Ogni worktree è un checkout separato sul suo ramo.

471

472```bash theme={null}

473claude --worktree feature-auth

474```

475

476Esegui lo stesso comando con un nome diverso in un secondo terminale per avviare una sessione parallela isolata. Vedi [Worktrees](/it/worktrees) per pulizia, `.worktreeinclude` e supporto VCS non-git. Per monitorare sessioni parallele da uno schermo invece di terminali separati, vedi [agenti in background](/it/agent-view).

477

478## Pianificare prima di modificare

479

480Per le modifiche che desideri rivedere prima che tocchino il disco, passa a plan mode. Claude legge i file e propone un piano ma non apporta modifiche finché non approvi.

481

482```bash theme={null}

483claude --permission-mode plan

484```

485

486Puoi anche premere `Shift+Tab` durante una sessione per attivare/disattivare plan mode. Vedi [Plan mode](/it/permission-modes#analyze-before-you-edit-with-plan-mode) per il flusso di approvazione e la modifica del piano nell'editor di testo.

487

488## Delegare la ricerca ai subagent

489

490Esplorare una base di codice grande riempie il tuo contesto con letture di file. Delega l'esplorazione in modo che solo i risultati tornino indietro.

491

492```text theme={null}

493use a subagent to investigate how our auth system handles token refresh

494```

495

496Il subagent legge i file nel suo proprio contesto e segnala un riassunto. Vedi [Subagent](/it/sub-agents) per definire agenti personalizzati con i loro strumenti e prompt.

497

498## Inviare Claude negli script

499

500Esegui Claude in modo non interattivo per CI, hook pre-commit o elaborazione batch. Stdin e stdout funzionano come qualsiasi strumento Unix.

501

502```bash theme={null}

503git log --oneline -20 | claude -p "summarize these recent commits"

504```

505

506Vedi [Modalità non interattiva](/it/headless) per formati di output, flag di autorizzazione e modelli fan-out.

507

1012## Passaggi successivi508## Passaggi successivi

1013 509

1014<CardGroup cols={2}>510<CardGroup cols={2}>

1016 Modelli per ottenere il massimo da Claude Code512 Modelli per ottenere il massimo da Claude Code

1017 </Card>513 </Card>

1018 514

1019 <Card title="Come funziona Claude Code" icon="gear" href="/it/how-claude-code-works">515 <Card title="Gestire le sessioni" icon="rotate-left" href="/it/sessions">

1020 Comprendi il ciclo agentico e la gestione del contesto516 Riprendere, denominare e dirammare conversazioni

1021 </Card>517 </Card>

1022 518

1023 <Card title="Estendere Claude Code" icon="puzzle-piece" href="/it/features-overview">519 <Card title="Worktrees" icon="code-branch" href="/it/worktrees">

1024 Aggiungi skills, hooks, MCP, subagent e plugin520 Eseguire sessioni parallele isolate

1025 </Card>521 </Card>

1026 522

1027 <Card title="Implementazione di riferimento" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">523 <Card title="Estendere Claude Code" icon="puzzle-piece" href="/it/features-overview">

1028 Clona l'implementazione di riferimento del contenitore di sviluppo524 Aggiungere skills, hooks, MCP, subagent e plugin

1029 </Card>525 </Card>

1030</CardGroup>526</CardGroup>

data-usage.md +11 −11

Details

67 67

68Il diagramma sottostante mostra come Claude Code si connette ai servizi esterni durante l'installazione e il funzionamento normale. Le linee continue indicano connessioni richieste, mentre le linee tratteggiate rappresentano flussi di dati facoltativi o avviati dall'utente.68Il diagramma sottostante mostra come Claude Code si connette ai servizi esterni durante l'installazione e il funzionamento normale. Le linee continue indicano connessioni richieste, mentre le linee tratteggiate rappresentano flussi di dati facoltativi o avviati dall'utente.

69 69

70<img src="https://mintcdn.com/claude-code/RcOyXc06Ja8cuvMZ/images/claude-code-data-flow.svg?fit=max&auto=format&n=RcOyXc06Ja8cuvMZ&q=85&s=b5be40abf333defe984993af89546c19" alt="Diagramma che mostra le connessioni esterne di Claude Code: install/update si connette al server di distribuzione e le richieste dell'utente si connettono ai servizi Anthropic inclusi Console auth, public-api e facoltativamente Statsig, Sentry e bug reporting" width="720" height="520" data-path="images/claude-code-data-flow.svg" />70<img src="https://mintcdn.com/claude-code/RcOyXc06Ja8cuvMZ/images/claude-code-data-flow.svg?fit=max&auto=format&n=RcOyXc06Ja8cuvMZ&q=85&s=b5be40abf333defe984993af89546c19" alt="Diagramma che mostra le connessioni esterne di Claude Code: install/update si connette al server di distribuzione e le richieste dell'utente si connettono ai servizi Anthropic inclusi Console auth, public-api e facoltativamente metrics, Sentry e bug reporting" width="720" height="520" data-path="images/claude-code-data-flow.svg" />

71 71

72Claude Code viene eseguito localmente. Per interagire con l'LLM, Claude Code invia dati sulla rete. Questi dati includono tutti i prompt dell'utente e gli output del modello, crittografati in transito tramite TLS 1.2+. Claude Code è compatibile con la maggior parte dei VPN e dei proxy LLM più diffusi.72Claude Code viene eseguito localmente. Per interagire con l'LLM, Claude Code invia dati sulla rete. Questi dati includono tutti i prompt dell'utente e gli output del modello, crittografati in transito tramite TLS 1.2+. Claude Code è compatibile con la maggior parte dei VPN e dei proxy LLM più diffusi.

73 73

95 95

96## Servizi di telemetria96## Servizi di telemetria

97 97

98Claude Code si connette dalle macchine degli utenti al servizio Statsig per registrare metriche operative come latenza, affidabilità e modelli di utilizzo. Questa registrazione non include alcun codice o percorso di file. I dati vengono crittografati in transito utilizzando TLS e a riposo utilizzando la crittografia AES a 256 bit. Scopri di più nella [documentazione sulla sicurezza di Statsig](https://www.statsig.com/trust/security). Per rinunciare alla telemetria di Statsig, impostate la variabile di ambiente `DISABLE_TELEMETRY`.98Claude Code si connette dalle macchine degli utenti ad Anthropic per registrare metriche operative come latenza, affidabilità e modelli di utilizzo. Questa registrazione non include alcun codice o percorso di file. I dati vengono crittografati in transito e a riposo. Per rinunciare alla telemetria, impostate la variabile di ambiente `DISABLE_TELEMETRY`.

99 99

100Claude Code si connette dalle macchine degli utenti a Sentry per la registrazione degli errori operativi. I dati vengono crittografati in transito utilizzando TLS e a riposo utilizzando la crittografia AES a 256 bit. Scopri di più nella [documentazione sulla sicurezza di Sentry](https://sentry.io/security/). Per rinunciare alla registrazione degli errori, impostate la variabile di ambiente `DISABLE_ERROR_REPORTING`.100Claude Code si connette dalle macchine degli utenti a Sentry per la registrazione degli errori operativi. I dati vengono crittografati in transito utilizzando TLS e a riposo utilizzando la crittografia AES a 256 bit. Scopri di più nella [documentazione sulla sicurezza di Sentry](https://sentry.io/security/). Per rinunciare alla registrazione degli errori, impostate la variabile di ambiente `DISABLE_ERROR_REPORTING`.

101 101

103 103

104## Comportamenti predefiniti per provider API104## Comportamenti predefiniti per provider API

105 105

106Per impostazione predefinita, la segnalazione degli errori, la telemetria e la segnalazione dei bug sono disabilitati quando si utilizza Bedrock, Vertex o Foundry. I sondaggi sulla qualità della sessione e il controllo di sicurezza del dominio WebFetch sono eccezioni e vengono eseguiti indipendentemente dal provider. Potete rinunciare a tutto il traffico non essenziale, inclusi i sondaggi, contemporaneamente impostando `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`. Questa variabile non influisce sul controllo WebFetch, che ha il suo proprio opt-out. Ecco i comportamenti predefiniti completi:106Per impostazione predefinita, la segnalazione degli errori, la telemetria e la segnalazione dei bug sono disabilitati quando si utilizza Bedrock, Vertex, Foundry o Claude Platform su AWS. I sondaggi sulla qualità della sessione e il controllo di sicurezza del dominio WebFetch sono eccezioni e vengono eseguiti indipendentemente dal provider. Potete rinunciare a tutto il traffico non essenziale, inclusi i sondaggi, contemporaneamente impostando `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`. Questa variabile non influisce sul controllo WebFetch, che ha il suo proprio opt-out. Ecco i comportamenti predefiniti completi:

107 107

109| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |109| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |

110| **Statsig (Metriche)** | Attivo per impostazione predefinita.<br />`DISABLE_TELEMETRY=1` per disabilitare. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_FOUNDRY` deve essere 1. |110| **Anthropic (Metriche)** | Attivo per impostazione predefinita.<br />`DISABLE_TELEMETRY=1` per disabilitare. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |

111| **Sentry (Errori)** | Attivo per impostazione predefinita.<br />`DISABLE_ERROR_REPORTING=1` per disabilitare. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_FOUNDRY` deve essere 1. |111| **Sentry (Errori)** | Attivo per impostazione predefinita.<br />`DISABLE_ERROR_REPORTING=1` per disabilitare. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |

112| **Claude API (report `/feedback`)** | Attivo per impostazione predefinita.<br />`DISABLE_FEEDBACK_COMMAND=1` per disabilitare. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_FOUNDRY` deve essere 1. |112| **Claude API (report `/feedback`)** | Attivo per impostazione predefinita.<br />`DISABLE_FEEDBACK_COMMAND=1` per disabilitare. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita.<br />`CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |

113| **Sondaggi sulla qualità della sessione** | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. |113| **Sondaggi sulla qualità della sessione** | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. |

114| **Controllo di sicurezza del dominio WebFetch** | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. |114| **Controllo di sicurezza del dominio WebFetch** | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. | Attivo per impostazione predefinita.<br />`skipWebFetchPreflight: true` in [settings](/it/settings) per disabilitare. |

115 115

116Tutte le variabili di ambiente possono essere controllate in `settings.json` (consultate [riferimento delle impostazioni](/it/settings)).116Tutte le variabili di ambiente possono essere controllate in `settings.json` (consultate [riferimento delle impostazioni](/it/settings)).

117 117

118A partire dalla v2.1.126, quando una piattaforma host imposta `CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`, le metriche Statsig sono attive per impostazione predefinita per Vertex, Bedrock e Foundry, e seguono l'opt-out standard `DISABLE_TELEMETRY`. La segnalazione degli errori Sentry e i report `/feedback` rimangono disattivi per impostazione predefinita su questi provider.118A partire dalla v2.1.126, quando una piattaforma host imposta `CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`, le metriche sono attive per impostazione predefinita per Vertex, Bedrock e Foundry, e seguono l'opt-out standard `DISABLE_TELEMETRY`. La segnalazione degli errori Sentry e i report `/feedback` rimangono disattivi per impostazione predefinita su questi provider.

119 119

120### Controllo di sicurezza del dominio WebFetch120### Controllo di sicurezza del dominio WebFetch

121 121

env-vars.md +11 −5

Details

12| :------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |12| :------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

13| `ANTHROPIC_API_KEY` | Chiave API inviata come intestazione `X-Api-Key`. Quando impostata, questa chiave viene utilizzata al posto del tuo abbonamento Claude Pro, Max, Team o Enterprise anche se sei connesso. In modalità non interattiva (`-p`), la chiave viene sempre utilizzata quando presente. In modalità interattiva, ti viene chiesto di approvare la chiave una volta prima che sostituisca il tuo abbonamento. Per utilizzare il tuo abbonamento, esegui `unset ANTHROPIC_API_KEY` |13| `ANTHROPIC_API_KEY` | Chiave API inviata come intestazione `X-Api-Key`. Quando impostata, questa chiave viene utilizzata al posto del tuo abbonamento Claude Pro, Max, Team o Enterprise anche se sei connesso. In modalità non interattiva (`-p`), la chiave viene sempre utilizzata quando presente. In modalità interattiva, ti viene chiesto di approvare la chiave una volta prima che sostituisca il tuo abbonamento. Per utilizzare il tuo abbonamento, esegui `unset ANTHROPIC_API_KEY` |

14| `ANTHROPIC_AUTH_TOKEN` | Valore personalizzato per l'intestazione `Authorization` (il valore che imposti qui sarà preceduto da `Bearer `) |14| `ANTHROPIC_AUTH_TOKEN` | Valore personalizzato per l'intestazione `Authorization` (il valore che imposti qui sarà preceduto da `Bearer `) |

15| `ANTHROPIC_AWS_API_KEY` | Chiave API dell'area di lavoro per [Claude Platform on AWS](/it/claude-platform-on-aws), generata nella Console AWS. Inviata come `x-api-key` e ha la precedenza su AWS SigV4 |

16| `ANTHROPIC_AWS_BASE_URL` | Sovrascrivi l'URL dell'endpoint [Claude Platform on AWS](/it/claude-platform-on-aws). Utilizza per regioni personalizzate o quando instrada attraverso un [gateway LLM](/it/llm-gateway). Per impostazione predefinita `https://aws-external-anthropic.{AWS_REGION}.api.aws` |

17| `ANTHROPIC_AWS_WORKSPACE_ID` | Obbligatorio per [Claude Platform on AWS](/it/claude-platform-on-aws). Inviato su ogni richiesta come intestazione `anthropic-workspace-id` |

15| `ANTHROPIC_BASE_URL` | Sovrascrivi l'endpoint API per instradare le richieste attraverso un proxy o gateway. Quando impostato su un host non di prima parte, la [ricerca degli strumenti MCP](/it/mcp#scale-with-mcp-tool-search) è disabilitata per impostazione predefinita. Imposta `ENABLE_TOOL_SEARCH=true` se il tuo proxy inoltra i blocchi `tool_reference` |18| `ANTHROPIC_BASE_URL` | Sovrascrivi l'endpoint API per instradare le richieste attraverso un proxy o gateway. Quando impostato su un host non di prima parte, la [ricerca degli strumenti MCP](/it/mcp#scale-with-mcp-tool-search) è disabilitata per impostazione predefinita. Imposta `ENABLE_TOOL_SEARCH=true` se il tuo proxy inoltra i blocchi `tool_reference` |

16| `ANTHROPIC_BEDROCK_BASE_URL` | Sovrascrivi l'URL dell'endpoint Bedrock. Utilizza per endpoint Bedrock personalizzati o quando instrada attraverso un [gateway LLM](/it/llm-gateway). Vedi [Amazon Bedrock](/it/amazon-bedrock) |19| `ANTHROPIC_BEDROCK_BASE_URL` | Sovrascrivi l'URL dell'endpoint Bedrock. Utilizza per endpoint Bedrock personalizzati o quando instrada attraverso un [gateway LLM](/it/llm-gateway). Vedi [Amazon Bedrock](/it/amazon-bedrock) |

17| `ANTHROPIC_BEDROCK_MANTLE_BASE_URL` | Sovrascrivi l'URL dell'endpoint Bedrock Mantle. Vedi [Endpoint Mantle](/it/amazon-bedrock#use-the-mantle-endpoint) |20| `ANTHROPIC_BEDROCK_MANTLE_BASE_URL` | Sovrascrivi l'URL dell'endpoint Bedrock Mantle. Vedi [Endpoint Mantle](/it/amazon-bedrock#use-the-mantle-endpoint) |

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 |48| `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/)) |49| `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/)) |

48| `BASH_MAX_OUTPUT_LENGTH` | Numero massimo di caratteri negli output bash prima che vengano troncati al centro |51| `BASH_MAX_OUTPUT_LENGTH` | Numero massimo di caratteri negli output bash prima che l'output completo venga salvato in un file e Claude riceva il percorso più un'anteprima breve. Vedi [Comportamento dello strumento Bash](/it/tools-reference#bash-tool-behavior) |

49| `BASH_MAX_TIMEOUT_MS` | Timeout massimo che il modello può impostare per i comandi bash a lunga esecuzione (predefinito: 600000, o 10 minuti) |52| `BASH_MAX_TIMEOUT_MS` | Timeout massimo che il modello può impostare per i comandi bash a lunga esecuzione (predefinito: 600000, o 10 minuti) |

50| `CCR_FORCE_BUNDLE` | Imposta su `1` per forzare [`claude --remote`](/it/claude-code-on-the-web#send-local-repositories-without-github) a raggruppare e caricare il tuo repository locale anche quando l'accesso a GitHub è disponibile |53| `CCR_FORCE_BUNDLE` | Imposta su `1` per forzare [`claude --remote`](/it/claude-code-on-the-web#send-local-repositories-without-github) a raggruppare e caricare il tuo repository locale anche quando l'accesso a GitHub è disponibile |

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

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

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

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

75| `CLAUDE_CODE_DISABLE_AGENT_VIEW` | Imposta su `1` per disattivare gli [agenti in background e la visualizzazione degli agenti](/it/agent-view): `claude agents`, `--bg`, `/background` e il supervisore su richiesta. Equivalente all'impostazione [`disableAgentView`](/it/settings#available-settings) |

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

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

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 |78| `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 anche quando [`autoMemoryEnabled: false`](/it/settings#available-settings) altrimenti la disabiliterebbe. Quando disabilitato, Claude non crea o carica i file di memoria automatica |

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

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

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

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

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

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 |111| `CLAUDE_CODE_GLOB_HIDDEN` | Imposta su `false` per escludere i dotfile dai risultati quando Claude richiama lo [strumento Glob](/it/tools-reference#glob-tool-behavior). Incluso per impostazione predefinita. Non influisce su `@` file autocomplete, `ls`, Grep o Read |

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) |112| `CLAUDE_CODE_GLOB_NO_IGNORE` | Imposta su `false` per fare in modo che lo [strumento Glob](/it/tools-reference#glob-tool-behavior) 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) |

109| `CLAUDE_CODE_GLOB_TIMEOUT_SECONDS` | Timeout in secondi per la scoperta dei file dello strumento Glob. Per impostazione predefinita 20 secondi sulla maggior parte delle piattaforme e 60 secondi su WSL |113| `CLAUDE_CODE_GLOB_TIMEOUT_SECONDS` | Timeout in secondi per la scoperta dei file dello strumento Glob. Per impostazione predefinita 20 secondi sulla maggior parte delle piattaforme e 60 secondi su WSL |

110| `CLAUDE_CODE_HIDE_CWD` | Imposta su `1` per nascondere la directory di lavoro nel logo di avvio. Utile per screenshare o registrazioni in cui il percorso espone il tuo nome utente del sistema operativo |114| `CLAUDE_CODE_HIDE_CWD` | Imposta su `1` per nascondere la directory di lavoro nel logo di avvio. Utile per screenshare o registrazioni in cui il percorso espone il tuo nome utente del sistema operativo |

111| `CLAUDE_CODE_IDE_HOST_OVERRIDE` | Sovrascrivi l'indirizzo host utilizzato per connettersi all'estensione IDE. Per impostazione predefinita Claude Code rileva automaticamente l'indirizzo corretto, incluso il routing WSL-to-Windows |115| `CLAUDE_CODE_IDE_HOST_OVERRIDE` | Sovrascrivi l'indirizzo host utilizzato per connettersi all'estensione IDE. Per impostazione predefinita Claude Code rileva automaticamente l'indirizzo corretto, incluso il routing WSL-to-Windows |

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

145| `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 |149| `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_SIMPLE_SYSTEM_PROMPT` | Imposta su `1` per utilizzare il prompt di sistema minimo e le descrizioni degli strumenti compresse su Opus 4.7. Non ha effetto su altri modelli. Il set di strumenti completo, hook, server MCP e scoperta CLAUDE.md rimangono abilitati |150| `CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT` | Imposta su `1` per utilizzare il prompt di sistema minimo e le descrizioni degli strumenti compresse su Opus 4.7. Non ha effetto su altri modelli. Il set di strumenti completo, hook, server MCP e scoperta CLAUDE.md rimangono abilitati |

151| `CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH` | Salta l'autenticazione lato client per [Claude Platform on AWS](/it/claude-platform-on-aws), per gateway che firmano le richieste stessi |

147| `CLAUDE_CODE_SKIP_BEDROCK_AUTH` | Salta l'autenticazione AWS per Bedrock (ad esempio, quando si utilizza un gateway LLM) |152| `CLAUDE_CODE_SKIP_BEDROCK_AUTH` | Salta l'autenticazione AWS per Bedrock (ad esempio, quando si utilizza un gateway LLM) |

148| `CLAUDE_CODE_SKIP_FOUNDRY_AUTH` | Salta l'autenticazione Azure per Microsoft Foundry (ad esempio, quando si utilizza un gateway LLM) |153| `CLAUDE_CODE_SKIP_FOUNDRY_AUTH` | Salta l'autenticazione Azure per Microsoft Foundry (ad esempio, quando si utilizza un gateway LLM) |

149| `CLAUDE_CODE_SKIP_MANTLE_AUTH` | Salta l'autenticazione AWS per Bedrock Mantle (ad esempio, quando si utilizza un gateway LLM) |154| `CLAUDE_CODE_SKIP_MANTLE_AUTH` | Salta l'autenticazione AWS per Bedrock Mantle (ad esempio, quando si utilizza un gateway LLM) |

158| `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) |163| `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) |

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

160| `CLAUDE_CODE_TMUX_TRUECOLOR` | Imposta su `1` per consentire l'output truecolor a 24 bit all'interno di tmux. Per impostazione predefinita, Claude Code si limita a 256 colori quando `$TMUX` è impostato perché tmux non passa attraverso le sequenze di escape truecolor a meno che non sia configurato per farlo. Imposta questo dopo aver aggiunto `set -ga terminal-overrides ',*:Tc'` al tuo `~/.tmux.conf`. Vedi [Configurazione del terminale](/it/terminal-config) per altre impostazioni di tmux |165| `CLAUDE_CODE_TMUX_TRUECOLOR` | Imposta su `1` per consentire l'output truecolor a 24 bit all'interno di tmux. Per impostazione predefinita, Claude Code si limita a 256 colori quando `$TMUX` è impostato perché tmux non passa attraverso le sequenze di escape truecolor a meno che non sia configurato per farlo. Imposta questo dopo aver aggiunto `set -ga terminal-overrides ',*:Tc'` al tuo `~/.tmux.conf`. Vedi [Configurazione del terminale](/it/terminal-config) per altre impostazioni di tmux |

166| `CLAUDE_CODE_USE_ANTHROPIC_AWS` | Utilizza [Claude Platform on AWS](/it/claude-platform-on-aws) |

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

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

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

199| `ENABLE_TOOL_SEARCH` | Controlla la [ricerca degli strumenti MCP](/it/mcp#scale-with-mcp-tool-search). Non impostato: tutti gli strumenti MCP differiti per impostazione predefinita, ma caricati in primo piano su Vertex AI o quando `ANTHROPIC_BASE_URL` punta a un host non di prima parte. Valori: `true` (sempre differire inclusi i proxy e Vertex AI), `auto` (modalità soglia: carica in primo piano se gli strumenti si adattano entro il 10% del contesto), `auto:N` (soglia personalizzata, ad es. `auto:5` per il 5%), `false` (carica tutto in primo piano) |205| `ENABLE_TOOL_SEARCH` | Controlla la [ricerca degli strumenti MCP](/it/mcp#scale-with-mcp-tool-search). Non impostato: tutti gli strumenti MCP differiti per impostazione predefinita, ma caricati in primo piano su Vertex AI o quando `ANTHROPIC_BASE_URL` punta a un host non di prima parte. Valori: `true` (sempre differire inclusi i proxy e Vertex AI), `auto` (modalità soglia: carica in primo piano se gli strumenti si adattano entro il 10% del contesto), `auto:N` (soglia personalizzata, ad es. `auto:5` per il 5%), `false` (carica tutto in primo piano) |

200| `FALLBACK_FOR_ALL_PRIMARY_MODELS` | Imposta su qualsiasi valore non vuoto per attivare il fallback a [`--fallback-model`](/it/cli-reference#cli-flags) dopo errori di sovraccarico ripetuti su qualsiasi modello primario. Per impostazione predefinita, solo i modelli Opus attivano il fallback |206| `FALLBACK_FOR_ALL_PRIMARY_MODELS` | Imposta su qualsiasi valore non vuoto per attivare il fallback a [`--fallback-model`](/it/cli-reference#cli-flags) dopo errori di sovraccarico ripetuti su qualsiasi modello primario. Per impostazione predefinita, solo i modelli Opus attivano il fallback |

glossary.md +8 −2

Details

126 126

127Ragionamento passo dopo passo visibile che il modello esegue prima di rispondere. Puoi limitare i token di thinking con `MAX_THINKING_TOKENS` o regolare il [effort level](#effort-level). Il thinking appare in testo grigio corsivo nel terminale.127Ragionamento passo dopo passo visibile che il modello esegue prima di rispondere. Puoi limitare i token di thinking con `MAX_THINKING_TOKENS` o regolare il [effort level](#effort-level). Il thinking appare in testo grigio corsivo nel terminale.

128 128

129Scopri di più: [Use extended thinking](/it/common-workflows#use-extended-thinking-thinking-mode)129Scopri di più: [Use extended thinking](/it/model-config#extended-thinking)

130 130

131## H131## H

132 132

286 286

287Scopri di più: [Tools available to Claude](/it/tools-reference)287Scopri di più: [Tools available to Claude](/it/tools-reference)

288 288

289### Turn

290

291Una risposta completa da Claude all'interno di una [session](#session). Un turn inizia quando invii un messaggio e termina quando Claude finisce di rispondere, con un numero qualsiasi di chiamate [tool](#tool) nel mezzo. Gli [stop hooks](#hook) si attivano alla fine di ogni turn. Una sessione è composta da molti turn, e l'[agentic loop](#agentic-loop) descrive ciò che accade all'interno di uno.

292

293Scopri di più: [How Claude Code works](/it/how-claude-code-works#the-agentic-loop)

294

289## W295## W

290 296

291### Worktree isolation297### Worktree isolation

292 298

293Una modalità di isolamento che esegue Claude in un worktree git separato in `.claude/worktrees/`, abilitata con il flag `-w` o `isolation: worktree` nella configurazione del subagent. Le modifiche rimangono su un branch separato in una directory separata, in modo che gli agenti paralleli non sovrascrivano i file l'uno dell'altro.299Una modalità di isolamento che esegue Claude in un worktree git separato in `.claude/worktrees/`, abilitata con il flag `-w` o `isolation: worktree` nella configurazione del subagent. Le modifiche rimangono su un branch separato in una directory separata, in modo che gli agenti paralleli non sovrascrivano i file l'uno dell'altro.

294 300

295Scopri di più: [Run parallel sessions with git worktrees](/it/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees)301Scopri di più: [Eseguire sessioni parallele con git worktrees](/it/worktrees)

296 302

297***303***

298 304

goal.md +138 −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# Mantenere Claude al lavoro verso un obiettivo

7> Imposta una condizione di completamento con /goal e Claude continua a lavorare tra i turni finché la condizione non è soddisfatta.

9Il comando `/goal` imposta una condizione di completamento e Claude continua a lavorare verso di essa senza che tu debba richiedere ogni passaggio. Dopo ogni turno, un piccolo modello veloce verifica se la condizione è soddisfatta. Se non lo è, Claude inizia un altro turno invece di restituire il controllo a te. L'obiettivo si cancella automaticamente una volta che la condizione è soddisfatta.

11Usa un obiettivo per lavori sostanziali con uno stato finale verificabile:

13* Migrazione di un modulo a una nuova API finché ogni sito di chiamata compila e i test passano

14* Implementazione di un documento di progettazione finché tutti i criteri di accettazione sono soddisfatti

15* Divisione di un file di grandi dimensioni in moduli focalizzati finché ciascuno è entro un budget di dimensioni

16* Elaborazione di un backlog di problemi etichettati finché la coda non è vuota

18Questa pagina copre come:

20* [Confrontare gli approcci di flusso di lavoro autonomo](#compare-to-other-autonomous-workflows): `/loop`, Stop hooks e auto mode

21* [Impostare un obiettivo](#set-a-goal) e [scrivere una condizione efficace](#write-an-effective-condition)

22* [Controllare lo stato](#check-status), [cancellare anticipatamente](#clear-a-goal) e [eseguire in modo non interattivo](#run-non-interactively)

23* Vedere [come funziona la valutazione](#how-evaluation-works) e [i requisiti](#requirements)

25## Confrontare con altri flussi di lavoro autonomi

27Tre approcci mantengono la sessione corrente in esecuzione tra i prompt. Scegli in base a cosa dovrebbe avviare il turno successivo:

29| Approccio | Il turno successivo inizia quando | Si ferma quando |

30| :------------------------------------------------------------------ | :-------------------------------- | :--------------------------------------------------- |

31| `/goal` | Il turno precedente finisce | Un modello conferma che la condizione è soddisfatta |

32| [`/loop`](/it/scheduled-tasks#run-a-prompt-repeatedly-with-%2Floop) | Un intervallo di tempo trascorre | Lo interrompi, o Claude decide che il lavoro è fatto |

33| [Stop hook](/it/hooks-guide#prompt-based-hooks) | Il turno precedente finisce | Il tuo script o prompt decide |

35`/goal` e uno Stop hook si attivano entrambi dopo ogni turno. `/goal` è un collegamento con ambito di sessione: digiti una condizione ed è attiva solo per la sessione corrente. Uno Stop hook risiede nel tuo file di impostazioni, si applica a ogni sessione nel suo ambito e può eseguire uno script per controlli deterministici o un prompt per quelli valutati dal modello.

37[Auto mode](/it/auto-mode-config) da solo approva le chiamate agli strumenti all'interno di un singolo turno ma non ne avvia uno nuovo. Claude si ferma quando giudica il lavoro completato. `/goal` aggiunge un valutatore separato che verifica la tua condizione dopo ogni turno, quindi il completamento è deciso da un modello nuovo piuttosto che da quello che sta facendo il lavoro. I due sono complementari: auto mode rimuove i prompt per strumento, e `/goal` rimuove i prompt per turno.

39<Tip>

40 Gli approcci sopra mantengono la sessione corrente in esecuzione. Puoi anche pianificare lavori che vengono eseguiti indipendentemente da qualsiasi sessione aperta, come test notturni o triage mattutino. Vedi [opzioni di pianificazione](/it/scheduled-tasks#compare-scheduling-options) per routine cloud e attività pianificate desktop.

41</Tip>

43## Usa `/goal`

45Un obiettivo può essere attivo per sessione. Lo stesso comando lo imposta, lo verifica e lo cancella a seconda dell'argomento.

47### Imposta un obiettivo

49Esegui `/goal` seguito dalla condizione che desideri soddisfatta. Se un obiettivo è già attivo, il nuovo lo sostituisce.

51```text theme={null}

52/goal all tests in test/auth pass and the lint step is clean

53```

55L'impostazione di un obiettivo avvia immediatamente un turno, con la condizione stessa come direttiva. Non è necessario inviare un prompt separato. Mentre l'obiettivo è attivo, un indicatore `◎ /goal active` mostra da quanto tempo l'obiettivo è in esecuzione.

57Dopo ogni turno, il valutatore restituisce una breve spiegazione del motivo per cui la condizione è o non è soddisfatta. Il motivo più recente appare nella vista dello stato e nella trascrizione in modo che tu possa vedere verso cosa Claude sta lavorando successivamente.

59<Note>

60 Un obiettivo continua a funzionare finché la condizione non è soddisfatta o finché non esegui `/goal clear`. Esegui `/goal` senza argomenti per vedere i turni e i token spesi finora.

61</Note>

63### Scrivi una condizione efficace

65Il [valutatore](#how-evaluation-works) giudica la tua condizione rispetto a ciò che Claude ha esposto nella conversazione. Non esegue comandi o legge file indipendentemente, quindi scrivi la condizione come qualcosa che l'output stesso di Claude può dimostrare. "Tutti i test in `test/auth` passano" funziona perché Claude esegue i test e il risultato finisce nella trascrizione affinché il valutatore lo legga.

67Una condizione che regge attraverso molti turni di solito ha:

69* **Uno stato finale misurabile**: un risultato di test, un codice di uscita della build, un conteggio di file, una coda vuota

70* **Un controllo dichiarato**: come Claude dovrebbe provarlo, come "`npm test` esce 0" o "`git status` è pulito"

71* **Vincoli che contano**: qualsiasi cosa che non deve cambiare nel percorso, come "nessun altro file di test viene modificato"

73La condizione può essere fino a 4.000 caratteri.

75Per limitare quanto a lungo un obiettivo viene eseguito, includi una clausola di turno o tempo nella condizione, come `or stop after 20 turns`. Claude segnala i progressi rispetto a quella clausola ogni turno e il valutatore la giudica dalla conversazione.

77### Controlla lo stato

79Esegui `/goal` senza argomenti per vedere lo stato corrente.

81```text theme={null}

82/goal

83```

85Se un obiettivo è attivo, lo stato mostra:

87* La condizione

88* Da quanto tempo è in esecuzione

89* Quanti turni sono stati valutati

90* La spesa di token corrente

91* Il motivo più recente del valutatore

93Se nessun obiettivo è attivo ma uno è stato raggiunto in precedenza nella sessione, lo stato mostra la condizione raggiunta insieme alla sua durata, conteggio dei turni e spesa di token.

95### Cancella un obiettivo

97Esegui `/goal clear` per rimuovere un obiettivo attivo prima che la sua condizione sia soddisfatta.

99```text theme={null}

100/goal clear

101```

102

103`stop`, `off`, `reset`, `none` e `cancel` sono accettati come alias per `clear`. L'esecuzione di `/clear` per avviare una nuova conversazione rimuove anche qualsiasi obiettivo attivo.

104

105### Riprendi con un obiettivo attivo

106

107Un obiettivo che era ancora attivo quando una sessione è terminata viene ripristinato quando riprendi quella sessione con `--resume` o `--continue`. La condizione viene trasferita, ma il conteggio dei turni, il timer e la linea di base della spesa di token si azzerano al ripristino. Un obiettivo che era già raggiunto o cancellato non viene ripristinato.

108

109### Esegui in modo non interattivo

110

111`/goal` funziona in [modalità non interattiva](/it/headless) e tramite [Remote Control](/it/remote-control). L'impostazione di un obiettivo con `-p` esegue il ciclo fino al completamento in una singola invocazione:

112

113```bash theme={null}

114claude -p "/goal CHANGELOG.md has an entry for every PR merged this week"

115```

116

117Interrompi il processo con Ctrl+C per fermare un obiettivo non interattivo prima che la condizione sia soddisfatta.

118

119## Come funziona la valutazione

120

121`/goal` è un wrapper attorno a uno [Stop hook basato su prompt](/it/hooks#prompt-based-hooks) con ambito di sessione. Ogni volta che Claude finisce un turno, la condizione e la conversazione finora vengono inviate al tuo [piccolo modello veloce](/it/model-config) configurato, che per impostazione predefinita è Haiku. Il modello restituisce una decisione sì o no e una breve spiegazione. Un "no" dice a Claude di continuare a lavorare e include il motivo come guida per il turno successivo. Un "sì" cancella l'obiettivo e registra una voce raggiunta nella trascrizione.

122

123Il valutatore viene eseguito su qualsiasi provider la tua sessione sia configurata. Non chiama strumenti, quindi può solo giudicare ciò che Claude ha già esposto nella conversazione.

124

125<Note>

126 I token di valutazione vengono fatturati sul piccolo modello veloce configurato per il tuo provider e sono in genere trascurabili rispetto alla spesa del turno principale.

127</Note>

128

129## Requisiti

130

131`/goal` viene eseguito solo negli spazi di lavoro in cui hai accettato la finestra di dialogo di fiducia, perché il valutatore fa parte del sistema di hook. Se [`disableAllHooks`](/it/hooks#disable-or-remove-hooks) è impostato nelle impostazioni dei criteri gestiti, `/goal` non è disponibile. In entrambi i casi, il comando ti dice perché invece di non fare nulla silenziosamente.

132

133## Vedi anche

134

135* [Esegui un prompt ripetutamente con `/loop`](/it/scheduled-tasks#run-a-prompt-repeatedly-with-%2Floop): riesegui a intervalli di tempo invece che finché una condizione non regge

136* [Hook basati su prompt](/it/hooks-guide#prompt-based-hooks): scrivi il tuo Stop hook quando hai bisogno di logica di valutazione personalizzata

137* [Auto mode](/it/auto-mode-config): approva le chiamate agli strumenti automaticamente in modo che ogni turno di obiettivo venga eseguito senza supervisione

138* [Confronto della pianificazione](/it/scheduled-tasks#compare-scheduling-options): esegui il lavoro secondo una pianificazione indipendente da qualsiasi sessione aperta

hooks.md +4 −0

Details

1768 1768

1769Viene eseguito quando l'agente Claude Code principale ha finito di rispondere. Non viene eseguito se l'arresto si è verificato a causa di un'interruzione dell'utente. Gli errori API attivano [StopFailure](#stopfailure) invece.1769Viene eseguito quando l'agente Claude Code principale ha finito di rispondere. Non viene eseguito se l'arresto si è verificato a causa di un'interruzione dell'utente. Gli errori API attivano [StopFailure](#stopfailure) invece.

1770 1770

1771<Tip>

1772 Il comando [`/goal`](/it/goal) è una scorciatoia incorporata per un hook Stop basato su prompt con ambito di sessione. Utilizzarlo quando si desidera che Claude continui a lavorare fino a quando una condizione non si verifica senza scrivere la configurazione dell'hook.

1773</Tip>

1774

1771#### Input di Stop1775#### Input di Stop

1772 1776

1773Oltre ai [campi di input comuni](#common-input-fields), gli hook Stop ricevono `stop_hook_active` e `last_assistant_message`. Il campo `stop_hook_active` è `true` quando Claude Code sta già continuando a causa di un hook di arresto. Controllare questo valore o elaborare la trascrizione per impedire a Claude Code di eseguire indefinitamente. Il campo `last_assistant_message` contiene il contenuto del testo della risposta finale di Claude, quindi gli hook possono accedervi senza analizzare il file della trascrizione.1777Oltre ai [campi di input comuni](#common-input-fields), gli hook Stop ricevono `stop_hook_active` e `last_assistant_message`. Il campo `stop_hook_active` è `true` quando Claude Code sta già continuando a causa di un hook di arresto. Controllare questo valore o elaborare la trascrizione per impedire a Claude Code di eseguire indefinitamente. Il campo `last_assistant_message` contiene il contenuto del testo della risposta finale di Claude, quindi gli hook possono accedervi senza analizzare il file della trascrizione.

interactive-mode.md +2 −2

Details

23### Controlli generali23### Controlli generali

24 24

26| :---------------------------------------------- | :--------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |26| :---------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

28| `Ctrl+X Ctrl+K` | Termina tutti gli agenti in background. Premere due volte entro 3 secondi per confermare | Controllo agente in background |28| `Ctrl+X Ctrl+K` | Termina tutti gli [agenti in background](/it/sub-agents#run-subagents-in-foreground-or-background) in questa sessione. Premere due volte entro 3 secondi per confermare | Controllo agente in background |

30| `Ctrl+G` o `Ctrl+X Ctrl+E` | Apri nell'editor di testo predefinito | Modifica il vostro prompt o la risposta personalizzata nell'editor di testo predefinito. `Ctrl+X Ctrl+E` è il binding nativo di readline. Attivare Mostra ultima risposta nell'editor esterno in `/config` per anteporre la risposta precedente di Claude come contesto commentato con `#` sopra il vostro prompt; il blocco di commento viene rimosso quando salvate |30| `Ctrl+G` o `Ctrl+X Ctrl+E` | Apri nell'editor di testo predefinito | Modifica il vostro prompt o la risposta personalizzata nell'editor di testo predefinito. `Ctrl+X Ctrl+E` è il binding nativo di readline. Attivare Mostra ultima risposta nell'editor esterno in `/config` per anteporre la risposta precedente di Claude come contesto commentato con `#` sopra il vostro prompt; il blocco di commento viene rimosso quando salvate |

31| `Ctrl+L` | Ridisegna lo schermo | Forza un ridisegno completo del terminale. L'input e la cronologia della conversazione vengono mantenuti. Utilizzate questo per recuperare se la visualizzazione diventa distorta o parzialmente vuota |31| `Ctrl+L` | Ridisegna lo schermo | Forza un ridisegno completo del terminale. L'input e la cronologia della conversazione vengono mantenuti. Utilizzate questo per recuperare se la visualizzazione diventa distorta o parzialmente vuota |

keybindings.md +1 −1

Details

105| `chat:clearInput` | Ctrl+L | Forza un ridisegno a schermo intero, preservando l'input. Nel [rendering a schermo intero](/it/fullscreen#clear-the-conversation), premi due volte entro due secondi per eseguire `/clear` |105| `chat:clearInput` | Ctrl+L | Forza un ridisegno a schermo intero, preservando l'input. Nel [rendering a schermo intero](/it/fullscreen#clear-the-conversation), premi due volte entro due secondi per eseguire `/clear` |

llm-gateway.md +11 −0

Details

186export CLOUD_ML_REGION=us-east5186export CLOUD_ML_REGION=us-east5

187```187```

188 188

189##### Claude Platform su AWS attraverso un gateway

190

191Instrada verso un gateway che inoltra all'endpoint [Claude Platform su AWS](/it/claude-platform-on-aws):

192

193```bash theme={null}

194export ANTHROPIC_AWS_BASE_URL=https://litellm-server:4000/anthropic-aws

195export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

196export CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1

197export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

198```

199

189Per informazioni più dettagliate, consulta la [documentazione di LiteLLM](https://docs.litellm.ai/).200Per informazioni più dettagliate, consulta la [documentazione di LiteLLM](https://docs.litellm.ai/).

190 201

191## Risorse aggiuntive202## Risorse aggiuntive

model-config.md +2 −2

Details

36| **`opus[1m]`** | Utilizza Opus con 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 |36| **`opus[1m]`** | Utilizza Opus con 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 |

38 38

39Su API Anthropic, `opus` si risolve in Opus 4.7 e `sonnet` si risolve in Sonnet 4.6. Su Bedrock, Vertex e Foundry, `opus` si risolve in Opus 4.6 e `sonnet` si risolve in Sonnet 4.5; modelli più recenti sono disponibili su questi provider selezionando il nome del modello completo esplicitamente o impostando `ANTHROPIC_DEFAULT_OPUS_MODEL` o `ANTHROPIC_DEFAULT_SONNET_MODEL`.39Su API Anthropic e [Claude Platform on AWS](/it/claude-platform-on-aws), `opus` si risolve in Opus 4.7 e `sonnet` si risolve in Sonnet 4.6. Su Bedrock, Vertex e Foundry, `opus` si risolve in Opus 4.6 e `sonnet` si risolve in Sonnet 4.5; modelli più recenti sono disponibili su questi provider selezionando il nome del modello completo esplicitamente o impostando `ANTHROPIC_DEFAULT_OPUS_MODEL` o `ANTHROPIC_DEFAULT_SONNET_MODEL`.

40 40

41Gli alias puntano alla versione consigliata per il provider e si aggiornano nel tempo. Per fissare una versione specifica, utilizzare il nome del modello completo (ad esempio, `claude-opus-4-7`) o impostare la variabile di ambiente corrispondente come `ANTHROPIC_DEFAULT_OPUS_MODEL`.41Gli alias puntano alla versione consigliata per il provider e si aggiornano nel tempo. Per fissare una versione specifica, utilizzare il nome del modello completo (ad esempio, `claude-opus-4-7`) o impostare la variabile di ambiente corrispondente come `ANTHROPIC_DEFAULT_OPUS_MODEL`.

42 42

294 294

295### Fissare i modelli per distribuzioni di terze parti295### Fissare i modelli per distribuzioni di terze parti

296 296

297Quando si distribuisce Claude Code tramite [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai) o [Foundry](/it/microsoft-foundry), fissare le versioni dei modelli prima di distribuire agli utenti.297Quando si distribuisce Claude Code tramite [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai), [Foundry](/it/microsoft-foundry), o [Claude Platform on AWS](/it/claude-platform-on-aws), fissare le versioni dei modelli prima di distribuire agli utenti.

298 298

299Senza fissaggio, Claude Code utilizza alias di modelli (`sonnet`, `opus`, `haiku`) che si risolvono nella versione più recente. Quando Anthropic rilascia un nuovo modello che non è ancora abilitato nell'account di un utente, gli utenti Bedrock e Vertex AI vedono un avviso e ricadono nella versione precedente per quella sessione, mentre gli utenti Foundry vedono errori perché Foundry non ha alcun controllo di avvio equivalente.299Senza fissaggio, Claude Code utilizza alias di modelli (`sonnet`, `opus`, `haiku`) che si risolvono nella versione più recente. Quando Anthropic rilascia un nuovo modello che non è ancora abilitato nell'account di un utente, gli utenti Bedrock e Vertex AI vedono un avviso e ricadono nella versione precedente per quella sessione, mentre gli utenti Foundry vedono errori perché Foundry non ha alcun controllo di avvio equivalente.

300 300

overview.md +1 −1

Details

172 <Accordion title="Esegui team di agenti e crea agenti personalizzati" icon="users">172 <Accordion title="Esegui team di agenti e crea agenti personalizzati" icon="users">

173 Genera [più agenti Claude Code](/it/sub-agents) che lavorano su diverse parti di un'attività contemporaneamente. Un agente principale coordina il lavoro, assegna sottoattività e unisce i risultati.173 Genera [più agenti Claude Code](/it/sub-agents) che lavorano su diverse parti di un'attività contemporaneamente. Un agente principale coordina il lavoro, assegna sottoattività e unisce i risultati.

174 174

175 Per flussi di lavoro completamente personalizzati, l'[Agent SDK](/it/agent-sdk/overview) ti permette di creare i tuoi agenti alimentati dagli strumenti e dalle capacità di Claude Code, con controllo completo sull'orchestrazione, l'accesso agli strumenti e i permessi.175 Per eseguire diverse sessioni complete in parallelo e osservarle da una sola schermata, utilizza [agenti in background](/it/agent-view). Per flussi di lavoro completamente personalizzati, l'[Agent SDK](/it/agent-sdk/overview) ti permette di creare i tuoi agenti alimentati dagli strumenti e dalle capacità di Claude Code, con controllo completo sull'orchestrazione, l'accesso agli strumenti e i permessi.

176 </Accordion>176 </Accordion>

177 177

178 <Accordion title="Pipe, script e automatizza con il CLI" icon="terminal">178 <Accordion title="Pipe, script e automatizza con il CLI" icon="terminal">

permissions.md +1 −1

Details

185Le regole `Edit` si applicano a tutti gli strumenti integrati che modificano i file. Claude fa un tentativo migliore per applicare le regole `Read` a tutti gli strumenti integrati che leggono file come Grep e Glob.185Le regole `Edit` si applicano a tutti gli strumenti integrati che modificano i file. Claude fa un tentativo migliore per applicare le regole `Read` a tutti gli strumenti integrati che leggono file come Grep e Glob.

186 186

187<Warning>187<Warning>

188 Le regole deny di Read e Edit si applicano agli strumenti di file integrati di Claude, non ai sottoprocessi Bash. Una regola deny `Read(./.env)` blocca lo strumento Read ma non impedisce `cat .env` in Bash. Per l'applicazione a livello del sistema operativo che blocca tutti i processi dall'accesso a un percorso, [abilitate la sandbox](/it/sandboxing).188 Le regole deny di Read e Edit si applicano agli strumenti di file integrati di Claude e ai comandi di file che Claude Code riconosce in Bash, come `cat`, `head`, `tail` e `sed`. Non si applicano a sottoprocessi arbitrari che leggono o scrivono file indirettamente, come uno script Python o Node che apre i file da solo. Per l'applicazione a livello del sistema operativo che blocca tutti i processi dall'accesso a un percorso, [abilitate la sandbox](/it/sandboxing).

189</Warning>189</Warning>

190 190

191Le regole Read e Edit seguono entrambe la specifica [gitignore](https://git-scm.com/docs/gitignore) con quattro tipi di modello distinti:191Le regole Read e Edit seguono entrambe la specifica [gitignore](https://git-scm.com/docs/gitignore) con quattro tipi di modello distinti:

scheduled-tasks.md +5 −3

Details

10 Le attività pianificate richiedono Claude Code v2.1.72 o versione successiva. Controllare la versione con `claude --version`.10 Le attività pianificate richiedono Claude Code v2.1.72 o versione successiva. Controllare la versione con `claude --version`.

11</Note>11</Note>

12 12

13Le attività pianificate consentono a Claude di rieseguire automaticamente un prompt a intervalli regolari. Utilizzarle per eseguire il polling di una distribuzione, monitorare una PR, controllare una compilazione a lunga esecuzione o ricordarsi di fare qualcosa più tardi nella sessione. Per reagire agli eventi man mano che si verificano invece di eseguire il polling, vedere [Channels](/it/channels): il vostro CI può inviare il fallimento direttamente nella sessione.13Le attività pianificate consentono a Claude di rieseguire automaticamente un prompt a intervalli regolari. Utilizzarle per eseguire il polling di una distribuzione, monitorare una PR, controllare una compilazione a lunga esecuzione o ricordarsi di fare qualcosa più tardi nella sessione. Per reagire agli eventi man mano che si verificano invece di eseguire il polling, vedere [Channels](/it/channels): il vostro CI può inviare il fallimento direttamente nella sessione. Per mantenere la sessione in funzione turno dopo turno fino al raggiungimento di una condizione piuttosto che a intervalli, vedere [`/goal`](/it/goal).

14 14

15Le attività hanno ambito di sessione: vivono nella conversazione corrente e si interrompono quando si avvia una nuova. La ripresa con `--resume` o `--continue` ripristina qualsiasi attività che non sia [scaduta](#seven-day-expiry): un'attività ricorrente creata negli ultimi 7 giorni, oppure una singola la cui ora pianificata non è ancora passata. Per la pianificazione che sopravvive indipendentemente da qualsiasi sessione, utilizzare [Routines](/it/routines), [Attività pianificate Desktop](/it/desktop-scheduled-tasks) o [GitHub Actions](/it/github-actions).15Le attività hanno ambito di sessione: vivono nella conversazione corrente e si interrompono quando si avvia una nuova. La ripresa con `--resume` o `--continue` ripristina qualsiasi attività che non sia [scaduta](#seven-day-expiry): un'attività ricorrente creata negli ultimi 7 giorni, oppure una singola la cui ora pianificata non è ancora passata. Per la pianificazione che sopravvive indipendentemente da qualsiasi sessione, utilizzare [Routines](/it/routines), [Attività pianificate Desktop](/it/desktop-scheduled-tasks) o [GitHub Actions](/it/github-actions).

16 16

122 122

123Per interrompere un `/loop` mentre è in attesa della successiva iterazione, premete `Esc`. Questo cancella il risveglio in sospeso in modo che il ciclo non si attivi di nuovo. Le attività pianificate [chiedendo direttamente a Claude](#manage-scheduled-tasks) non sono interessate da `Esc` e rimangono in posizione fino a quando non le eliminate.123Per interrompere un `/loop` mentre è in attesa della successiva iterazione, premete `Esc`. Questo cancella il risveglio in sospeso in modo che il ciclo non si attivi di nuovo. Le attività pianificate [chiedendo direttamente a Claude](#manage-scheduled-tasks) non sono interessate da `Esc` e rimangono in posizione fino a quando non le eliminate.

124 124

125In [modalità autonoma](#let-claude-choose-the-interval), Claude può anche terminare il ciclo da solo non pianificando il successivo risveglio una volta che l'attività è provabilmente completata. I cicli su un intervallo fisso continuano a funzionare fino a quando non li interrompete o [trascorrono sette giorni](#seven-day-expiry).

126

125## Impostare un promemoria una tantum127## Impostare un promemoria una tantum

126 128

127Per promemoria una tantum, descrivete quello che volete in linguaggio naturale invece di utilizzare `/loop`. Claude pianifica un'attività a fuoco singolo che si elimina dopo l'esecuzione.129Per promemoria una tantum, descrivete quello che volete in linguaggio naturale invece di utilizzare `/loop`. Claude pianifica un'attività a fuoco singolo che si elimina dopo l'esecuzione.

166 168

167### Jitter169### Jitter

168 170

169Per evitare che ogni sessione colpisca l'API nello stesso momento del muro, lo scheduler aggiunge un piccolo offset deterministico ai tempi di attivazione:171Per evitare che ogni sessione colpisca l'API nello stesso momento, lo scheduler aggiunge un offset deterministico ai tempi di attivazione:

170 172

171* Le attività ricorrenti si attivano fino al 10% del loro periodo in ritardo, limitato a 15 minuti. Un processo orario potrebbe attivarsi da `:00` a `:06`.173* Le attività ricorrenti si attivano fino a 30 minuti dopo l'ora pianificata (o fino a metà dell'intervallo, per le attività che vengono eseguite più frequentemente di ogni ora). Un processo orario pianificato per `:00` potrebbe attivarsi in qualsiasi momento fino a `:30`.

172* Le attività una tantum pianificate per l'inizio o la fine dell'ora si attivano fino a 90 secondi prima.174* Le attività una tantum pianificate per l'inizio o la fine dell'ora si attivano fino a 90 secondi prima.

173 175

174L'offset è derivato dall'ID dell'attività, quindi la stessa attività ottiene sempre lo stesso offset. Se il timing esatto è importante, scegliete un minuto che non sia `:00` o `:30`, ad esempio `3 9 * * *` invece di `0 9 * * *`, e il jitter una tantum non si applicherà.176L'offset è derivato dall'ID dell'attività, quindi la stessa attività ottiene sempre lo stesso offset. Se il timing esatto è importante, scegliete un minuto che non sia `:00` o `:30`, ad esempio `3 9 * * *` invece di `0 9 * * *`, e il jitter una tantum non si applicherà.

settings.md +1 −0

Details

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

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

185| `deniedMcpServers` | Quando impostato in managed-settings.json, elenco di negazione dei MCP server che sono esplicitamente bloccati. Si applica a tutti gli ambiti inclusi i server gestiti. L'elenco di negazione ha la precedenza sull'elenco di autorizzazione. Vedi [Configurazione MCP gestita](/it/mcp#managed-mcp-configuration) | `[{ "serverName": "filesystem" }]` |185| `deniedMcpServers` | Quando impostato in managed-settings.json, elenco di negazione dei MCP server che sono esplicitamente bloccati. Si applica a tutti gli ambiti inclusi i server gestiti. L'elenco di negazione ha la precedenza sull'elenco di autorizzazione. Vedi [Configurazione MCP gestita](/it/mcp#managed-mcp-configuration) | `[{ "serverName": "filesystem" }]` |

186| `disableAgentView` | Imposta a `true` per disattivare gli [agenti in background e la visualizzazione degli agenti](/it/agent-view): `claude agents`, `--bg`, `/background`, e il supervisore su richiesta. Tipicamente impostato nelle [impostazioni gestite](/it/permissions#managed-settings). Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_AGENT_VIEW` a `1` | `true` |

187| `disableAutoMode` | Imposta a `"disable"` per prevenire l'attivazione della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove `auto` dal ciclo `Shift+Tab` e rifiuta `--permission-mode auto` all'avvio. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `"disable"` |188| `disableAutoMode` | Imposta a `"disable"` per prevenire l'attivazione della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove `auto` dal ciclo `Shift+Tab` e rifiuta `--permission-mode auto` all'avvio. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `"disable"` |

188| `disableDeepLinkRegistration` | Imposta a `"disable"` per prevenire che Claude Code registri il gestore del protocollo `claude-cli://` con il sistema operativo all'avvio. I [deep link](/it/deep-links) consentono agli strumenti esterni di aprire una sessione di Claude Code con un prompt pre-compilato. Utile negli ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente | `"disable"` |189| `disableDeepLinkRegistration` | Imposta a `"disable"` per prevenire che Claude Code registri il gestore del protocollo `claude-cli://` con il sistema operativo all'avvio. I [deep link](/it/deep-links) consentono agli strumenti esterni di aprire una sessione di Claude Code con un prompt pre-compilato. Utile negli ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente | `"disable"` |

sub-agents.md +8 −8

Details

11Ogni subagent viene eseguito nella propria finestra di contesto con un prompt di sistema personalizzato, accesso a strumenti specifici e autorizzazioni indipendenti. Quando Claude incontra un'attività che corrisponde alla descrizione di un subagent, la delega a quel subagent, che lavora in modo indipendente e restituisce i risultati. Per vedere il risparmio di contesto in pratica, la [visualizzazione della finestra di contesto](/it/context-window) illustra una sessione in cui un subagent gestisce la ricerca nella sua finestra separata.11Ogni subagent viene eseguito nella propria finestra di contesto con un prompt di sistema personalizzato, accesso a strumenti specifici e autorizzazioni indipendenti. Quando Claude incontra un'attività che corrisponde alla descrizione di un subagent, la delega a quel subagent, che lavora in modo indipendente e restituisce i risultati. Per vedere il risparmio di contesto in pratica, la [visualizzazione della finestra di contesto](/it/context-window) illustra una sessione in cui un subagent gestisce la ricerca nella sua finestra separata.

12 12

13<Note>13<Note>

14 Se ha bisogno di più agenti che lavorano in parallelo e comunicano tra loro, consulti invece [agent teams](/it/agent-teams). I subagent lavorano all'interno di una singola sessione; i team di agenti coordinano tra sessioni separate.14 I subagent funzionano all'interno di una singola sessione. Per eseguire molte sessioni indipendenti in parallelo e monitorarle da un unico posto, consulti [background agents](/it/agent-view). Per sessioni che comunicano tra loro, consulti [agent teams](/it/agent-teams).

15</Note>15</Note>

16 16

17I subagent la aiutano a:17I subagent la aiutano a:

158 158

159Questo è il modo consigliato per creare e gestire i subagent. Per la creazione manuale o l'automazione, può anche aggiungere file subagent direttamente.159Questo è il modo consigliato per creare e gestire i subagent. Per la creazione manuale o l'automazione, può anche aggiungere file subagent direttamente.

160 160

161Per elencare tutti i subagent configurati dalla riga di comando senza avviare una sessione interattiva, esegua `claude agents`. Questo mostra gli agenti raggruppati per fonte e indica quali sono sovrascritti da definizioni di priorità più alta.161Per elencare tutti i subagent configurati dalla riga di comando senza aprire la [visualizzazione agente](/it/agent-view), esegua il piping dell'output di `claude agents`. Ad esempio, `claude agents | cat` stampa gli agenti raggruppati per fonte e indica quali sono sovrascritti da definizioni di priorità più alta.

162 162

163### Scelga l'ambito del subagent163### Scelga l'ambito del subagent

164 164

260 260

262| :---------------- | :------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |262| :---------------- | :------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

263| `name` | Yes | Identificatore univoco utilizzando lettere minuscole e trattini |263| `name` | Yes | Identificatore univoco utilizzando lettere minuscole e trattini. [Hooks](/it/hooks#subagentstart) ricevono questo valore come `agent_type`. Il nome del file non deve corrispondere |

264| `description` | Yes | Quando Claude dovrebbe delegare a questo subagent |264| `description` | Yes | Quando Claude dovrebbe delegare a questo subagent |

265| `tools` | No | [Strumenti](#available-tools) che il subagent può utilizzare. Eredita tutti gli strumenti se omesso. Per precaricare Skills nel contesto, usi il campo `skills` piuttosto che elencare `Skill` qui |265| `tools` | No | [Strumenti](#available-tools) che il subagent può utilizzare. Eredita tutti gli strumenti se omesso. Per precaricare Skills nel contesto, usi il campo `skills` piuttosto che elencare `Skill` qui |

266| `disallowedTools` | No | Strumenti da negare, rimossi dall'elenco ereditato o specificato |266| `disallowedTools` | No | Strumenti da negare, rimossi dall'elenco ereditato o specificato |

666 666

667I subagent possono essere eseguiti in primo piano (bloccante) o in background (concorrente):667I subagent possono essere eseguiti in primo piano (bloccante) o in background (concorrente):

668 668

669* **Subagent in primo piano** bloccano la conversazione principale fino al completamento. I prompt di autorizzazione e le domande di chiarimento (come [`AskUserQuestion`](/it/tools-reference)) vengono passati a lei.669* **Subagent in primo piano** bloccano la conversazione principale fino al completamento. I prompt di autorizzazione vengono passati a lei mentre si presentano.

670* **Subagent in background** vengono eseguiti contemporaneamente mentre continua a lavorare. Prima di avviare, Claude Code richiede le autorizzazioni di strumenti di cui il subagent avrà bisogno, assicurando che abbia le approvazioni necessarie in anticipo. Una volta in esecuzione, il subagent eredita queste autorizzazioni e auto-nega qualsiasi cosa non pre-approvata. Se un subagent in background ha bisogno di fare domande di chiarimento, quella chiamata di strumento fallisce ma il subagent continua.670* **Subagent in background** vengono eseguiti contemporaneamente mentre continua a lavorare. Vengono eseguiti con le autorizzazioni già concesse nella sessione e auto-negano qualsiasi chiamata di strumento che altrimenti richiederebbe un prompt. Se un subagent in background ha bisogno di fare domande di chiarimento, quella chiamata di strumento fallisce ma il subagent continua.

671 671

672Se un subagent in background fallisce a causa di autorizzazioni mancanti, può avviare un nuovo subagent in primo piano con lo stesso compito per riprovare con prompt interattivi.672Se un subagent in background fallisce a causa di autorizzazioni mancanti, può avviare un nuovo subagent in primo piano con lo stesso compito per riprovare con prompt interattivi.

673 673

678 678

679Per disabilitare tutta la funzionalità di background task, imposti la variabile di ambiente `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS` su `1`. Consulti [Environment variables](/it/env-vars).679Per disabilitare tutta la funzionalità di background task, imposti la variabile di ambiente `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS` su `1`. Consulti [Environment variables](/it/env-vars).

680 680

681Quando la [fork mode](#fork-the-current-conversation) è abilitata, ogni spawn di subagent viene eseguito in background indipendentemente dal campo `background`. I fork continuano a far emergere i prompt di autorizzazione nel suo terminale mentre si verificano invece di pre-approvare; i subagent denominati seguono il flusso di pre-approvazione sopra.681Quando la [fork mode](#fork-the-current-conversation) è abilitata, ogni spawn di subagent viene eseguito in background indipendentemente dal campo `background`. I fork continuano a far emergere i prompt di autorizzazione nel suo terminale mentre si verificano; i subagent denominati auto-negano qualsiasi cosa che altrimenti richiederebbe un prompt, come descritto sopra.

682 682

683### Modelli comuni683### Modelli comuni

684 684

824Un fork eredita tutto ciò che la sessione principale ha nel momento in cui viene generato. Un subagent denominato inizia dalla sua propria definizione.824Un fork eredita tutto ciò che la sessione principale ha nel momento in cui viene generato. Un subagent denominato inizia dalla sua propria definizione.

825 825

826| | Fork | Subagent denominato |826| | Fork | Subagent denominato |

827| :-------------------- | :----------------------------------- | :----------------------------------------------------------------------------------------------- |827| :-------------------- | :----------------------------------- | :-------------------------------------------------------------------------------------------- |

833 833

834Poiché il prompt di sistema di un fork e le definizioni di strumenti sono identici al principale, la sua prima richiesta riutilizza la cache del prompt del principale. Questo rende il fork più economico rispetto alla generazione di un subagent fresco per attività che necessitano dello stesso contesto.834Poiché il prompt di sistema di un fork e le definizioni di strumenti sono identici al principale, la sua prima richiesta riutilizza la cache del prompt del principale. Questo rende il fork più economico rispetto alla generazione di un subagent fresco per attività che necessitano dello stesso contesto.

third-party-integrations.md +14 −4

Details

99 <th>Claude for Teams/Enterprise</th>99 <th>Claude for Teams/Enterprise</th>

100 <th>Anthropic Console</th>100 <th>Anthropic Console</th>

101 <th>Amazon Bedrock</th>101 <th>Amazon Bedrock</th>

102 <th>Claude Platform on AWS</th>

102 <th>Google Vertex AI</th>103 <th>Google Vertex AI</th>

103 <th>Microsoft Foundry</th>104 <th>Microsoft Foundry</th>

104 </tr>105 </tr>

110 <td>La maggior parte delle organizzazioni (consigliato)</td>111 <td>La maggior parte delle organizzazioni (consigliato)</td>

111 <td>Sviluppatori individuali</td>112 <td>Sviluppatori individuali</td>

112 <td>Distribuzioni native AWS</td>113 <td>Distribuzioni native AWS</td>

114 <td>Fatturazione AWS Marketplace con funzionalità Claude API</td>

113 <td>Distribuzioni native GCP</td>115 <td>Distribuzioni native GCP</td>

114 <td>Distribuzioni native Azure</td>116 <td>Distribuzioni native Azure</td>

115 </tr>117 </tr>

119 <td><strong>Teams:</strong> \$150/seat (Premium) con PAYG disponibile<br /><strong>Enterprise:</strong> <a href="https://claude.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=third_party_enterprise">Contatta il team di vendita</a></td>121 <td><strong>Teams:</strong> \$150/seat (Premium) con PAYG disponibile<br /><strong>Enterprise:</strong> <a href="https://claude.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=third_party_enterprise">Contatta il team di vendita</a></td>

120 <td>PAYG</td>122 <td>PAYG</td>

121 <td>PAYG tramite AWS</td>123 <td>PAYG tramite AWS</td>

124 <td>PAYG tramite AWS Marketplace</td>

122 <td>PAYG tramite GCP</td>125 <td>PAYG tramite GCP</td>

123 <td>PAYG tramite Azure</td>126 <td>PAYG tramite Azure</td>

124 </tr>127 </tr>

128 <td>Paesi supportati [countries](https://www.anthropic.com/supported-countries)</td>131 <td>Paesi supportati [countries](https://www.anthropic.com/supported-countries)</td>

129 <td>Paesi supportati [countries](https://www.anthropic.com/supported-countries)</td>132 <td>Paesi supportati [countries](https://www.anthropic.com/supported-countries)</td>

130 <td>Più [regions](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) AWS</td>133 <td>Più [regions](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) AWS</td>

134 <td>Più regioni AWS</td>

131 <td>Più [regions](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations) GCP</td>135 <td>Più [regions](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations) GCP</td>

132 <td>Più [regions](https://azure.microsoft.com/en-us/explore/global-infrastructure/products-by-region/) Azure</td>136 <td>Più [regions](https://azure.microsoft.com/en-us/explore/global-infrastructure/products-by-region/) Azure</td>

133 </tr>137 </tr>

134 138

135 <tr>139 <tr>

136 <td>prompt caching</td>140 <td>Prompt caching</td>

141 <td>Abilitato per impostazione predefinita</td>

137 <td>Abilitato per impostazione predefinita</td>142 <td>Abilitato per impostazione predefinita</td>

138 <td>Abilitato per impostazione predefinita</td>143 <td>Abilitato per impostazione predefinita</td>

139 <td>Abilitato per impostazione predefinita</td>144 <td>Abilitato per impostazione predefinita</td>

146 <td>Claude.ai SSO o email</td>151 <td>Claude.ai SSO o email</td>

147 <td>API key</td>152 <td>API key</td>

148 <td>API key o credenziali AWS</td>153 <td>API key o credenziali AWS</td>

154 <td>API key o credenziali AWS</td>

149 <td>Credenziali GCP</td>155 <td>Credenziali GCP</td>

150 <td>API key o Microsoft Entra ID</td>156 <td>API key o Microsoft Entra ID</td>

151 </tr>157 </tr>

155 <td>Dashboard di utilizzo</td>161 <td>Dashboard di utilizzo</td>

156 <td>Dashboard di utilizzo</td>162 <td>Dashboard di utilizzo</td>

157 <td>AWS Cost Explorer</td>163 <td>AWS Cost Explorer</td>

164 <td>AWS Cost Explorer</td>

158 <td>GCP Billing</td>165 <td>GCP Billing</td>

159 <td>Azure Cost Management</td>166 <td>Azure Cost Management</td>

160 </tr>167 </tr>

166 <td>No</td>173 <td>No</td>

167 <td>No</td>174 <td>No</td>

168 <td>No</td>175 <td>No</td>

176 <td>No</td>

169 </tr>177 </tr>

170 178

171 <tr>179 <tr>

173 <td>Gestione del team, SSO, monitoraggio dell'utilizzo</td>181 <td>Gestione del team, SSO, monitoraggio dell'utilizzo</td>

174 <td>Nessuna</td>182 <td>Nessuna</td>

175 <td>Policy IAM, CloudTrail</td>183 <td>Policy IAM, CloudTrail</td>

184 <td>Policy IAM, CloudTrail</td>

176 <td>Ruoli IAM, Cloud Audit Logs</td>185 <td>Ruoli IAM, Cloud Audit Logs</td>

177 <td>Policy RBAC, Azure Monitor</td>186 <td>Policy RBAC, Azure Monitor</td>

178 </tr>187 </tr>

184* [Claude for Teams o Enterprise](/it/authentication#claude-for-teams-or-enterprise)193* [Claude for Teams o Enterprise](/it/authentication#claude-for-teams-or-enterprise)

185* [Anthropic Console](/it/authentication#claude-console-authentication)194* [Anthropic Console](/it/authentication#claude-console-authentication)

186* [Amazon Bedrock](/it/amazon-bedrock)195* [Amazon Bedrock](/it/amazon-bedrock)

196* [Claude Platform on AWS](/it/claude-platform-on-aws)

187* [Google Vertex AI](/it/google-vertex-ai)197* [Google Vertex AI](/it/google-vertex-ai)

188* [Microsoft Foundry](/it/microsoft-foundry)198* [Microsoft Foundry](/it/microsoft-foundry)

189 199

192La maggior parte delle organizzazioni può utilizzare un provider cloud direttamente senza configurazione aggiuntiva. Tuttavia, potrebbe essere necessario configurare un proxy aziendale o un gateway LLM se la tua organizzazione ha requisiti di rete o gestione specifici. Queste sono configurazioni diverse che possono essere utilizzate insieme:202La maggior parte delle organizzazioni può utilizzare un provider cloud direttamente senza configurazione aggiuntiva. Tuttavia, potrebbe essere necessario configurare un proxy aziendale o un gateway LLM se la tua organizzazione ha requisiti di rete o gestione specifici. Queste sono configurazioni diverse che possono essere utilizzate insieme:

193 203

194* **Corporate proxy**: Instrada il traffico attraverso un proxy HTTP/HTTPS. Utilizzalo se la tua organizzazione richiede che tutto il traffico in uscita passi attraverso un server proxy per il monitoraggio della sicurezza, la conformità o l'applicazione della policy di rete. Configura con le variabili di ambiente `HTTPS_PROXY` o `HTTP_PROXY`. Scopri di più in [Enterprise network configuration](/it/network-config).204* **Corporate proxy**: Instrada il traffico attraverso un proxy HTTP/HTTPS. Utilizzalo se la tua organizzazione richiede che tutto il traffico in uscita passi attraverso un server proxy per il monitoraggio della sicurezza, la conformità o l'applicazione della policy di rete. Configura con le variabili di ambiente `HTTPS_PROXY` o `HTTP_PROXY`. Scopri di più in [Enterprise network configuration](/it/network-config).

195* **LLM Gateway**: Un servizio che si trova tra Claude Code e il provider cloud per gestire l'autenticazione e il routing. Utilizzalo se hai bisogno di tracciamento centralizzato dell'utilizzo tra i team, rate limiting personalizzato o budget, o gestione centralizzata dell'autenticazione. Configura con le variabili di ambiente `ANTHROPIC_BASE_URL`, `ANTHROPIC_BEDROCK_BASE_URL`, o `ANTHROPIC_VERTEX_BASE_URL`. Scopri di più in [LLM gateway configuration](/it/llm-gateway).205* **LLM Gateway**: Un servizio che si trova tra Claude Code e il provider cloud per gestire l'autenticazione e il routing. Utilizzalo se hai bisogno di tracciamento centralizzato dell'utilizzo tra i team, rate limiting personalizzato o budget, o gestione centralizzata dell'autenticazione. Configura con le variabili di ambiente `ANTHROPIC_BASE_URL`, `ANTHROPIC_BEDROCK_BASE_URL`, `ANTHROPIC_AWS_BASE_URL`, o `ANTHROPIC_VERTEX_BASE_URL`. Scopri di più in [LLM gateway configuration](/it/llm-gateway).

196 206

197I seguenti esempi mostrano le variabili di ambiente da impostare nella tua shell o nel profilo shell (`.bashrc`, `.zshrc`). Vedi [Settings](/it/settings) per altri metodi di configurazione.207I seguenti esempi mostrano le variabili di ambiente da impostare nella tua shell o nel profilo shell (`.bashrc`, `.zshrc`). Vedi [Settings](/it/settings) per altri metodi di configurazione.

198 208

292 Usa `/status` in Claude Code per verificare che la configurazione del proxy e del gateway sia applicata correttamente.302 Usa `/status` in Claude Code per verificare che la configurazione del proxy e del gateway sia applicata correttamente.

293</Tip>303</Tip>

294 304

295## Best practice per le organizzazioni305## Best practices for organizations

296 306

297### Investi nella documentazione e nella memoria307### Investi nella documentazione e nella memoria

298 308

313 323

314### Fissa le versioni dei modelli per i provider cloud324### Fissa le versioni dei modelli per i provider cloud

315 325

316Se distribuisci tramite [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai), o [Foundry](/it/microsoft-foundry), fissa versioni specifiche dei modelli utilizzando `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, e `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Senza fissare, gli alias dei modelli si risolvono nella versione più recente, che potrebbe non essere ancora abilitata nel tuo account quando Anthropic rilascia un aggiornamento. Fissare le versioni ti consente di controllare quando i tuoi utenti passano a un nuovo modello. Vedi [Model configuration](/it/model-config#pin-models-for-third-party-deployments) per ciò che ogni provider fa quando la versione più recente non è disponibile.326Se distribuisci tramite [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai), [Foundry](/it/microsoft-foundry), o [Claude Platform on AWS](/it/claude-platform-on-aws), fissa versioni specifiche dei modelli utilizzando `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, e `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Senza fissare, gli alias dei modelli si risolvono nella versione più recente, che potrebbe non essere ancora abilitata nel tuo account quando Anthropic rilascia un aggiornamento. Fissare le versioni ti consente di controllare quando i tuoi utenti passano a un nuovo modello. Vedi [Model configuration](/it/model-config#pin-models-for-third-party-deployments) per ciò che ogni provider fa quando la versione più recente non è disponibile.

317 327

318### Configura le policy di sicurezza328### Configura le policy di sicurezza

319 329

tools-reference.md +181 −14

Details

4 4

5# Riferimento degli strumenti5# Riferimento degli strumenti

6 6

~~7> Riferimento completo per gli strumenti che Claude Code può utilizzare, inclusi i requisiti di autorizzazione.~~7> Riferimento completo per gli strumenti che Claude Code può utilizzare, inclusi i requisiti di autorizzazione e il comportamento per strumento.

8 8

9Claude Code ha accesso a un set di strumenti integrati che lo aiutano a comprendere e modificare la tua codebase. I nomi degli strumenti sono le stringhe esatte che utilizzi nelle [regole di autorizzazione](/it/permissions#tool-specific-permission-rules), [elenchi di strumenti subagent](/it/sub-agents), e [hook matchers](/it/hooks). Per disabilitare completamente uno strumento, aggiungi il suo nome all'array `deny` nelle tue [impostazioni di autorizzazione](/it/permissions#tool-specific-permission-rules).9Claude Code ha accesso a un set di strumenti integrati che lo aiutano a comprendere e modificare la tua codebase. I nomi degli strumenti sono le stringhe esatte che utilizzi nelle [regole di autorizzazione specifiche dello strumento](/it/permissions#tool-specific-permission-rules), [elenchi di strumenti subagent](/it/sub-agents), e [hook matchers](/it/hooks). Per disabilitare completamente uno strumento, aggiungi il suo nome all'array `deny` nelle tue [impostazioni di autorizzazione](/it/permissions#tool-specific-permission-rules).

10 10

11Per aggiungere strumenti personalizzati, connetti un [server MCP](/it/mcp). Per estendere Claude con flussi di lavoro basati su prompt riutilizzabili, scrivi una [skill](/it/skills), che viene eseguita attraverso lo strumento `Skill` esistente piuttosto che aggiungere una nuova voce di strumento.11Per aggiungere strumenti personalizzati, connetti un [server MCP](/it/mcp). Per estendere Claude con flussi di lavoro basati su prompt riutilizzabili, scrivi una [skill](/it/skills), che viene eseguita attraverso lo strumento `Skill` esistente piuttosto che aggiungere una nuova voce di strumento.

12 12

14| :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------- |14| :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------- |

15| `Agent` | Genera un [subagent](/it/sub-agents) con la propria finestra di contesto per gestire un'attività | No |15| `Agent` | Genera un [subagent](/it/sub-agents) con la propria finestra di contesto per gestire un'attività. Vedi [comportamento dello strumento Agent](#agent-tool-behavior) | No |

16| `AskUserQuestion` | Pone domande a scelta multipla per raccogliere requisiti o chiarire ambiguità | No |16| `AskUserQuestion` | Pone domande a scelta multipla per raccogliere requisiti o chiarire ambiguità | No |

17| `Bash` | Esegue comandi shell nel tuo ambiente. Vedi [comportamento dello strumento Bash](#bash-tool-behavior) | Sì |17| `Bash` | Esegue comandi shell nel tuo ambiente. Vedi [comportamento dello strumento Bash](#bash-tool-behavior) | Sì |

18| `CronCreate` | Pianifica un prompt ricorrente o una tantum all'interno della sessione corrente. Le attività hanno ambito di sessione e vengono ripristinate su `--resume` o `--continue` se non scadute. Vedi [attività pianificate](/it/scheduled-tasks) | No |18| `CronCreate` | Pianifica un prompt ricorrente o una tantum all'interno della sessione corrente. Le attività hanno ambito di sessione e vengono ripristinate su `--resume` o `--continue` se non scadute. Vedi [attività pianificate](/it/scheduled-tasks) | No |

19| `CronDelete` | Annulla un'attività pianificata per ID | No |19| `CronDelete` | Annulla un'attività pianificata per ID | No |

20| `CronList` | Elenca tutte le attività pianificate nella sessione | No |20| `CronList` | Elenca tutte le attività pianificate nella sessione | No |

21| `Edit` | Effettua modifiche mirate a file specifici | Sì |21| `Edit` | Effettua modifiche mirate a file specifici. Vedi [comportamento dello strumento Edit](#edit-tool-behavior) | Sì |

22| `EnterPlanMode` | Passa a Plan Mode per progettare un approccio prima di codificare | No |22| `EnterPlanMode` | Passa a Plan Mode per progettare un approccio prima di codificare | No |

23| `EnterWorktree` | Crea un [git worktree](/it/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) isolato e vi accede. Passa un `path` per accedere a un worktree esistente del repository corrente invece di crearne uno nuovo. Non disponibile per i subagent | No |23| `EnterWorktree` | Crea un [git worktree](/it/worktrees) isolato e vi accede. Passa un `path` per accedere a un worktree esistente del repository corrente invece di crearne uno nuovo. Non disponibile per i subagent | No |

24| `ExitPlanMode` | Presenta un piano per l'approvazione ed esce da Plan Mode | Sì |24| `ExitPlanMode` | Presenta un piano per l'approvazione ed esce da Plan Mode | Sì |

25| `ExitWorktree` | Esce da una sessione worktree e ritorna alla directory originale. Non disponibile per i subagent | No |25| `ExitWorktree` | Esce da una sessione worktree e ritorna alla directory originale. Non disponibile per i subagent | No |

26| `Glob` | Trova file in base alla corrispondenza di pattern | No |26| `Glob` | Trova file in base alla corrispondenza di pattern. Vedi [comportamento dello strumento Glob](#glob-tool-behavior) | No |

27| `Grep` | Cerca pattern nei contenuti dei file | No |27| `Grep` | Cerca pattern nei contenuti dei file. Vedi [comportamento dello strumento Grep](#grep-tool-behavior) | No |

28| `ListMcpResourcesTool` | Elenca le risorse esposte dai [server MCP](/it/mcp) connessi | No |28| `ListMcpResourcesTool` | Elenca le risorse esposte dai [server MCP](/it/mcp) connessi | No |

29| `LSP` | Intelligenza del codice tramite language server: salta alle definizioni, trova riferimenti, segnala errori di tipo e avvisi. Vedi [comportamento dello strumento LSP](#lsp-tool-behavior) | No |29| `LSP` | Intelligenza del codice tramite language server: salta alle definizioni, trova riferimenti, segnala errori di tipo e avvisi. Vedi [comportamento dello strumento LSP](#lsp-tool-behavior) | No |

30| `Monitor` | Esegue un comando in background e restituisce ogni riga di output a Claude, in modo che possa reagire alle voci di log, ai cambiamenti di file, o allo stato sottoposto a polling durante la conversazione. Vedi [strumento Monitor](#monitor-tool) | Sì |30| `Monitor` | Esegue un comando in background e restituisce ogni riga di output a Claude, in modo che possa reagire alle voci di log, ai cambiamenti di file, o allo stato sottoposto a polling durante la conversazione. Vedi [strumento Monitor](#monitor-tool) | Sì |

31| `NotebookEdit` | Modifica le celle del notebook Jupyter | Sì |31| `NotebookEdit` | Modifica le celle del notebook Jupyter. Vedi [comportamento dello strumento NotebookEdit](#notebookedit-tool-behavior) | Sì |

32| `PowerShell` | Esegue comandi PowerShell nativamente. Vedi [strumento PowerShell](#powershell-tool) per la disponibilità | Sì |32| `PowerShell` | Esegue comandi PowerShell nativamente. Vedi [strumento PowerShell](#powershell-tool) per la disponibilità | Sì |

33| `Read` | Legge il contenuto dei file | No |33| `PushNotification` | Invia una notifica desktop e una push su telefono quando [Remote Control](/it/remote-control) è connesso, in modo che un'attività di lunga durata o un'[attività pianificata](/it/scheduled-tasks) possa raggiungerti quando ti allontani. {/* plan-availability: feature=push-notifications providers=anthropic */}La consegna push viene eseguita attraverso l'infrastruttura ospitata da Anthropic, che non è accessibile da Amazon Bedrock, Google Vertex AI, o Microsoft Foundry | No |

34| `Read` | Legge il contenuto dei file. Vedi [comportamento dello strumento Read](#read-tool-behavior) | No |

34| `ReadMcpResourceTool` | Legge una risorsa MCP specifica per URI | No |35| `ReadMcpResourceTool` | Legge una risorsa MCP specifica per URI | No |

36| `RemoteTrigger` | Crea, aggiorna, esegue ed elenca [Routine](/it/routines) su claude.ai. Supporta il comando `/schedule`. {/* plan-availability: feature=routines plans=pro,max,team,enterprise providers=anthropic */}Le Routine vivono su claude.ai e richiedono un piano Pro, Max, Team, o Enterprise, quindi questo strumento non è accessibile da Amazon Bedrock, Google Vertex AI, o Microsoft Foundry | No |

35| `SendMessage` | Invia un messaggio a un [team di agenti](/it/agent-teams) compagno, o [riprende un subagent](/it/sub-agents#resume-subagents) per il suo ID agente. I subagent interrotti si riprendono automaticamente in background. Disponibile solo quando `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` è impostato | No |37| `SendMessage` | Invia un messaggio a un [team di agenti](/it/agent-teams) compagno, o [riprende un subagent](/it/sub-agents#resume-subagents) per il suo ID agente. I subagent interrotti si riprendono automaticamente in background. Disponibile solo quando `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` è impostato | No |

38| `ShareOnboardingGuide` | {/* plan-availability: feature=onboarding-guide-share plans=pro,max,team,enterprise providers=anthropic */}Carica `ONBOARDING.md` e restituisce un link di condivisione che i compagni di team possono aprire in Claude Code. Chiamato da `/team-onboarding` dopo che la guida è stata scritta. Disponibile per gli abbonati di claude.ai su piani Pro, Max, Team, ed Enterprise | Sì |

36| `Skill` | Esegue una [skill](/it/skills#control-who-invokes-a-skill) all'interno della conversazione principale | Sì |39| `Skill` | Esegue una [skill](/it/skills#control-who-invokes-a-skill) all'interno della conversazione principale | Sì |

37| `TaskCreate` | Crea una nuova attività nell'elenco delle attività | No |40| `TaskCreate` | Crea una nuova attività nell'elenco delle attività | No |

38| `TaskGet` | Recupera i dettagli completi per un'attività specifica | No |41| `TaskGet` | Recupera i dettagli completi per un'attività specifica | No |

44| `TeamDelete` | Scioglie un team di agenti e pulisce i processi dei compagni. Disponibile solo quando `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` è impostato | No |47| `TeamDelete` | Scioglie un team di agenti e pulisce i processi dei compagni. Disponibile solo quando `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` è impostato | No |

45| `TodoWrite` | Gestisce l'elenco di controllo delle attività della sessione. Disponibile in modalità non interattiva e in [Agent SDK](/it/headless); le sessioni interattive utilizzano TaskCreate, TaskGet, TaskList, e TaskUpdate | No |48| `TodoWrite` | Gestisce l'elenco di controllo delle attività della sessione. Disponibile in modalità non interattiva e in [Agent SDK](/it/headless); le sessioni interattive utilizzano TaskCreate, TaskGet, TaskList, e TaskUpdate | No |

46| `ToolSearch` | Cerca e carica strumenti differiti quando [tool search](/it/mcp#scale-with-mcp-tool-search) è abilitato | No |49| `ToolSearch` | Cerca e carica strumenti differiti quando [tool search](/it/mcp#scale-with-mcp-tool-search) è abilitato | No |

47| `WebFetch` | Recupera il contenuto da un URL specificato | Sì |50| `WebFetch` | Recupera il contenuto da un URL specificato. Vedi [comportamento dello strumento WebFetch](#webfetch-tool-behavior) | Sì |

48| `WebSearch` | Esegue ricerche web | Sì |51| `WebSearch` | Esegue ricerche web. Vedi [comportamento dello strumento WebSearch](#websearch-tool-behavior) | Sì |

49| `Write` | Crea o sovrascrivi file | Sì |52| `Write` | Crea o sovrascrivi file. Vedi [comportamento dello strumento Write](#write-tool-behavior) | Sì |

50 53

51Le regole di autorizzazione possono essere configurate utilizzando `/permissions` o nelle [impostazioni di autorizzazione](/it/settings#available-settings). Vedi anche [Regole di autorizzazione specifiche dello strumento](/it/permissions#tool-specific-permission-rules).54## Configura gli strumenti con regole di autorizzazione e hook

56Per la maggior parte, Claude decide quando utilizzare questi strumenti e non è necessario nominarli tu stesso quando interagisci con Claude. Fai riferimento ai nomi degli strumenti direttamente quando definisci autorizzazioni e altre configurazioni:

58* in [`permissions.allow` e `permissions.deny`](/it/settings#available-settings) nelle impostazioni, e nell'interfaccia `/permissions`

59* nei flag CLI [`--allowedTools` e `--disallowedTools`](/it/cli-reference)

60* nelle opzioni [`allowedTools` e `disallowedTools`](/it/agent-sdk/permissions#allow-and-deny-rules) dell'Agent SDK

61* nel frontmatter `tools` o `disallowedTools` di un [subagent](/it/sub-agents#supported-frontmatter-fields)

62* nel frontmatter [`allowed-tools`](/it/skills#frontmatter-reference) di una skill

63* nella condizione [`if`](/it/hooks-guide#filter-by-tool-name-and-arguments-with-the-if-field) di un hook

65Tutti questi accettano lo stesso formato di regola, `ToolName(specifier)`. Lo specifier dipende dallo strumento, e diversi strumenti condividono un formato:

67| Formato di regola | Si applica a | Dettagli |

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

69| `Bash(npm run *)` | Bash, Monitor | [Corrispondenza di pattern di comando](/it/permissions#bash) |

70| `PowerShell(Get-ChildItem *)` | PowerShell | [Corrispondenza di pattern di comando](/it/permissions#powershell) |

71| `Read(~/secrets/**)` | Read, Grep, Glob, LSP | [Corrispondenza di pattern di percorso](/it/permissions#read-and-edit) |

72| `Edit(/src/**)` | Edit, Write, NotebookEdit | [Corrispondenza di pattern di percorso](/it/permissions#read-and-edit) |

73| `Skill(deploy *)` | Skill | [Corrispondenza di nome skill](/it/skills#restrict-claude's-skill-access) |

74| `Agent(Explore)` | Agent | [Corrispondenza di tipo subagent](/it/permissions#agent-subagents) |

75| `WebFetch(domain:example.com)` | WebFetch | [Corrispondenza di dominio](/it/permissions#webfetch) |

76| `WebSearch` | WebSearch | Nessuno specifier; consenti o nega lo strumento nel suo insieme |

78Gli strumenti non elencati qui, come `ExitPlanMode` o `ShareOnboardingGuide`, accettano solo il nome dello strumento nudo senza specifier.

80Una regola di autorizzazione `Edit(...)` concede anche accesso in lettura allo stesso percorso, quindi non hai bisogno di una regola `Read(...)` corrispondente.

82I campi `matcher` degli hook utilizzano nomi di strumenti nudi, non il formato tra parentesi. Vedi [matcher patterns](/it/hooks#matcher-patterns) per le regole di corrispondenza. Per i nomi di campo che ogni strumento passa a `tool_input` negli hook, vedi il [riferimento di input PreToolUse](/it/hooks#pretooluse-input).

84## Comportamento dello strumento Agent

86Lo strumento Agent genera un subagent in una finestra di contesto separata. Il subagent lavora attraverso il suo compito autonomamente, quindi restituisce un singolo risultato di testo alla conversazione principale. Il genitore non vede le chiamate di strumento intermedie o gli output del subagent, solo quel risultato finale. Per limitare quanti turni un subagent esegue, imposta `maxTurns` nella [definizione del subagent](/it/sub-agents#supported-frontmatter-fields).

88Lo stesso strumento Agent avvia anche [subagent biforcati](/it/sub-agents#fork-the-current-conversation) quando la modalità fork è abilitata. Un fork eredita la conversazione principale completa invece di iniziare da zero, viene sempre eseguito in background, e comunque fa emergere i prompt di autorizzazione nel tuo terminale. Il resto di questa sezione descrive i subagent denominati.

90Quali strumenti un subagent denominato può utilizzare dipende dai campi `tools` e `disallowedTools` nella [definizione del subagent](/it/sub-agents):

92* **Nessun campo impostato**: il subagent eredita ogni strumento disponibile al genitore.

93* **Solo `tools`**: il subagent ottiene solo gli strumenti elencati.

94* **Solo `disallowedTools`**: il subagent ottiene ogni strumento del genitore tranne quelli elencati.

95* **Entrambi impostati**: `disallowedTools` ha la precedenza. Uno strumento elencato in entrambi viene rimosso.

97L'avvio del subagent non richiede di per sé l'autorizzazione. Le chiamate di strumento del subagent vengono controllate rispetto alle tue regole di autorizzazione mentre viene eseguito:

99* **Subagent in primo piano** mostrano gli stessi prompt di autorizzazione che vedresti nella conversazione principale, nel momento in cui ogni chiamata di strumento accade.

100* **Subagent in background** non mostrano prompt. Vengono eseguiti con le autorizzazioni già concesse nella sessione e negano automaticamente qualsiasi chiamata di strumento che altrimenti richiederebbe un prompt. Dopo un rifiuto, il subagent continua senza quello strumento.

101

102Per limitare cosa un subagent può raggiungere in primo luogo, restringi il suo campo `tools`, lascia Bash fuori dall'elenco, o imposta regole di negazione nelle tue impostazioni, come descritto in [Controlla le capacità del subagent](/it/sub-agents#control-subagent-capabilities). Per ulteriori informazioni sulla scelta tra primo piano e background, vedi [Esegui subagent in primo piano o background](/it/sub-agents#run-subagents-in-foreground-or-background).

52 103

53## Comportamento dello strumento Bash104## Comportamento dello strumento Bash

54 105

61 112

62Attiva il tuo virtualenv o ambiente conda prima di avviare Claude Code. Per fare in modo che le variabili di ambiente persistano tra i comandi Bash, imposta [`CLAUDE_ENV_FILE`](/it/env-vars) su uno script shell prima di avviare Claude Code, oppure utilizza un [hook SessionStart](/it/hooks#persist-environment-variables) per popolarlo dinamicamente.113Attiva il tuo virtualenv o ambiente conda prima di avviare Claude Code. Per fare in modo che le variabili di ambiente persistano tra i comandi Bash, imposta [`CLAUDE_ENV_FILE`](/it/env-vars) su uno script shell prima di avviare Claude Code, oppure utilizza un [hook SessionStart](/it/hooks#persist-environment-variables) per popolarlo dinamicamente.

63 114

115Due limiti vincolano ogni comando:

116

117* **Timeout**: due minuti per impostazione predefinita. Claude può richiedere fino a 10 minuti per comando con il parametro `timeout`. Sostituisci il valore predefinito e il limite massimo con [`BASH_DEFAULT_TIMEOUT_MS` e `BASH_MAX_TIMEOUT_MS`](/it/env-vars).

118* **Lunghezza dell'output**: 30.000 caratteri per impostazione predefinita. Quando un comando produce più di quello, Claude Code salva l'output completo in un file nella directory della sessione e fornisce a Claude il percorso del file più un'anteprima breve dall'inizio. Claude legge o cerca quel file quando ha bisogno del resto. Aumenta il limite con [`BASH_MAX_OUTPUT_LENGTH`](/it/env-vars), fino a un limite massimo fisso di 150.000 caratteri.

119

120Per processi di lunga durata come server di sviluppo o build di watch, Claude può impostare `run_in_background: true` per avviare il comando come attività in background e continuare a lavorare mentre viene eseguito. Elenca e interrompi le attività in background con `/tasks`.

121

122## Comportamento dello strumento Edit

123

124Lo strumento Edit esegue la sostituzione di stringhe esatte. Prende un `old_string` e un `new_string` e sostituisce il primo con il secondo. Non utilizza regex o corrispondenza fuzzy.

125

126Tre controlli devono passare affinché un'edit si applichi:

127

128* **Lettura prima dell'edit**: Claude deve aver letto il file nella conversazione corrente, e il file non deve essere cambiato su disco da quella lettura. Questo controllo viene eseguito per primo, prima di qualsiasi corrispondenza di stringhe.

129* **Corrispondenza**: `old_string` deve apparire nel file esattamente come scritto. Una singola differenza di carattere di spazio o indentazione è sufficiente per mancare.

130* **Unicità**: `old_string` deve apparire esattamente una volta. Quando appare più di una volta, Claude fornisce una stringa più lunga con abbastanza contesto circostante per individuare un'occorrenza, o imposta `replace_all: true` per sostituirle tutte.

131

132Visualizzare un file con Bash soddisfa anche il requisito di lettura prima dell'edit quando il comando è `cat path/to/file` o `sed -n 'X,Yp' path/to/file` su un singolo file senza pipe o reindirizzamenti. Altri comandi Bash come `head`, `tail`, o output con pipe non contano, e Claude deve utilizzare Read prima di modificare in quei casi.

133

134Questo influisce solo sull'idoneità dell'edit, non sulle autorizzazioni. Le [regole di negazione Read e Edit](/it/permissions#tool-specific-permission-rules) si applicano anche ai comandi di file che Claude Code riconosce in Bash, come `cat`, `head`, `tail`, e `sed`, ma non ai sottoprocessi arbitrari che leggono o scrivono file indirettamente, come uno script Python o Node che apre file da solo. Per l'applicazione a livello di sistema operativo che copre ogni processo, [abilita la sandbox](/it/sandboxing).

135

136## Comportamento dello strumento Glob

137

138Lo strumento Glob trova file per pattern di nome. Supporta la sintassi glob standard incluso `**` per la corrispondenza ricorsiva di directory:

139

140* `**/*.js` corrisponde a tutti i file `.js` a qualsiasi profondità

141* `src/**/*.ts` corrisponde a tutti i file `.ts` sotto `src/`

142* `*.{json,yaml}` corrisponde ai file `.json` e `.yaml` nella directory corrente

143

144I risultati sono ordinati per tempo di modifica e limitati a 100 file. Se il limite viene raggiunto, Claude vede un flag di troncamento nel risultato e può restringere il pattern.

145

146Glob non rispetta `.gitignore` per impostazione predefinita, quindi trova file gitignored insieme a quelli tracciati. Questo differisce da [Grep](#grep-tool-behavior), che salta i file gitignored. Per fare in modo che Glob rispetti `.gitignore`, imposta `CLAUDE_CODE_GLOB_NO_IGNORE=false` prima di avviare Claude Code.

147

148## Comportamento dello strumento Grep

149

150Lo strumento Grep cerca pattern nei contenuti dei file. Dove [Glob](#glob-tool-behavior) trova file per nome, Grep trova righe dentro di loro.

151

152Grep è costruito su [ripgrep](https://github.com/BurntSushi/ripgrep) e utilizza la sintassi regex di ripgrep, non grep POSIX. I pattern che includono metacaratteri regex hanno bisogno di escape. Ad esempio, trovare `interface{}` nel codice Go richiede il pattern `interface\{\}`.

153

154Tre modalità di output controllano cosa viene restituito:

155

156* `files_with_matches`: solo percorsi di file, nessun contenuto di riga. Questo è il valore predefinito.

157* `content`: righe corrispondenti con file e numero di riga.

158* `count`: conteggio delle corrispondenze per file.

159

160Claude può limitare i risultati per file con il parametro `glob`, come `**/*.tsx`, o per linguaggio con il parametro `type`, come `py` o `rust`. Per impostazione predefinita, i pattern corrispondono all'interno di una singola riga. Claude può impostare `multiline: true` per corrispondere attraverso i confini di riga.

161

162Grep rispetta `.gitignore`, quindi i file gitignored vengono saltati. Per cercare un file gitignored, Claude passa il suo percorso direttamente.

163

64## Comportamento dello strumento LSP164## Comportamento dello strumento LSP

65 165

66Lo strumento LSP fornisce a Claude intelligenza del codice da un language server in esecuzione. Dopo ogni modifica di file, segnala automaticamente errori di tipo e avvisi in modo che Claude possa correggere i problemi senza un passaggio di compilazione separato. Claude può anche chiamarlo direttamente per navigare il codice:166Lo strumento LSP fornisce a Claude intelligenza del codice da un language server in esecuzione. Dopo ogni modifica di file, segnala automaticamente errori di tipo e avvisi in modo che Claude possa correggere i problemi senza un passaggio di compilazione separato. Claude può anche chiamarlo direttamente per navigare il codice:

93 193

94I plugin possono dichiarare monitor che si avviano automaticamente quando il plugin è attivo, invece di chiedere a Claude di avviarli. Vedi [plugin monitors](/it/plugins-reference#monitors).194I plugin possono dichiarare monitor che si avviano automaticamente quando il plugin è attivo, invece di chiedere a Claude di avviarli. Vedi [plugin monitors](/it/plugins-reference#monitors).

95 195

196## Comportamento dello strumento NotebookEdit

197

198NotebookEdit modifica un notebook Jupyter una cella alla volta, puntando alle celle per il loro `cell_id`. Non esegue la sostituzione di stringhe attraverso il notebook come fa [Edit](#edit-tool-behavior) sui file semplici.

199

200Tre modalità di edit controllano cosa accade alla cella target:

201

202* `replace`: sovrascrivi la sorgente della cella. Questo è il valore predefinito.

203* `insert`: aggiungi una nuova cella dopo la target. Senza `cell_id`, la nuova cella va all'inizio del notebook. Richiede `cell_type` impostato a `code` o `markdown`.

204* `delete`: rimuovi la cella target.

205

206Le regole di autorizzazione utilizzano il formato di percorso `Edit(...)`. Una regola come `Edit(notebooks/**)` copre le chiamate NotebookEdit su file in quella directory.

207

96## Strumento PowerShell208## Strumento PowerShell

97 209

98Lo strumento PowerShell consente a Claude di eseguire comandi PowerShell nativamente. Su Windows, questo significa che i comandi vengono eseguiti in PowerShell invece di essere instradati attraverso Git Bash. Su Windows senza Git Bash, lo strumento è abilitato automaticamente. Su Windows con Git Bash installato, lo strumento è in rollout progressivo. Su Linux, macOS e WSL, lo strumento è opt-in.210Lo strumento PowerShell consente a Claude di eseguire comandi PowerShell nativamente. Su Windows, questo significa che i comandi vengono eseguiti in PowerShell invece di essere instradati attraverso Git Bash. Su Windows senza Git Bash, lo strumento è abilitato automaticamente. Su Windows con Git Bash installato, lo strumento è in rollout progressivo. Su Linux, macOS e WSL, lo strumento è opt-in.

130* I profili PowerShell non vengono caricati242* I profili PowerShell non vengono caricati

131* Su Windows, il sandboxing non è supportato243* Su Windows, il sandboxing non è supportato

132 244

245## Comportamento dello strumento Read

246

247Lo strumento Read prende un percorso di file e restituisce i contenuti con numeri di riga. Claude è istruito a passare sempre percorsi assoluti.

248

249Per impostazione predefinita, Read restituisce il file dall'inizio. I file oltre una soglia di dimensione restituiscono un errore piuttosto che contenuto parziale, richiedendo a Claude di riprovare con `offset` e `limit` per leggere un intervallo specifico.

250

251Read gestisce diversi tipi di file oltre al testo semplice:

252

253* **Immagini**: PNG, JPG e altri formati di immagine vengono restituiti come contenuto visivo che Claude può vedere, non come byte grezzi. Claude Code ridimensiona e ricomprime le immagini grandi per adattarsi ai limiti di dimensione dell'immagine del modello prima di inviarle, quindi Claude potrebbe vedere una versione ridotta di uno screenshot grande. Se Claude perde dettagli a livello di pixel fine in un'immagine grande, chiedigli di ritagliare prima la regione di interesse, ad esempio con ImageMagick tramite Bash.

254* **PDF**: Claude legge file `.pdf` brevi nel loro insieme. Per i PDF più lunghi di 10 pagine, legge in intervalli con un parametro `pages`, come `"1-5"`, fino a 20 pagine alla volta.

255* **Notebook Jupyter**: i file `.ipynb` restituiscono tutte le celle con i loro output, inclusi codice, markdown e visualizzazioni.

256

257Read legge solo file, non directory. Claude utilizza `ls` tramite lo strumento Bash per elencare i contenuti della directory.

258

259## Comportamento dello strumento WebFetch

260

261WebFetch prende un URL e un prompt che descrive cosa estrarre. Recupera la pagina, converte la risposta in Markdown quando il server restituisce HTML, ed esegue il prompt contro il contenuto utilizzando un modello piccolo e veloce. Per la maggior parte dei recuperi, Claude riceve la risposta di quel modello, non la pagina grezza. Il passaggio di conversione non è configurabile.

262

263Questo rende WebFetch lossy per progettazione. Il prompt di estrazione determina cosa raggiunge Claude, quindi un risultato che dice che una pagina non menziona qualcosa potrebbe significare solo che il prompt non l'ha chiesto. Chiedi a Claude di recuperare di nuovo con un prompt più specifico, o utilizza `curl` tramite Bash per la pagina non elaborata.

264

265Alcuni comportamenti modellano la risposta che Claude riceve:

266

267* Gli URL HTTP vengono automaticamente aggiornati a HTTPS.

268* Le pagine grandi vengono troncate a un limite di caratteri fisso prima dell'elaborazione.

269* Le risposte vengono memorizzate nella cache per 15 minuti, quindi i recuperi ripetuti dello stesso URL vengono restituiti rapidamente.

270* Quando un URL reindirizza a un host diverso, WebFetch restituisce un risultato di testo che nomina l'URL originale e il target di reindirizzamento invece di seguirlo. Claude quindi recupera il nuovo URL con una seconda chiamata WebFetch.

271

272Nelle modalità di autorizzazione predefinita e `acceptEdits`, WebFetch richiede la prima volta che raggiunge un nuovo dominio. Per consentire un dominio in anticipo senza un prompt, aggiungi una regola di autorizzazione come `WebFetch(domain:example.com)`. Le modalità di autorizzazione `auto` e `bypassPermissions` saltano completamente il prompt.

273

274WebFetch imposta un'intestazione `User-Agent` che inizia con `Claude-User`, e un'intestazione `Accept` che preferisce Markdown a HTML in modo che i server che supportano la negoziazione dei contenuti possano restituire Markdown direttamente. Le [regole di rete della Sandbox](/it/sandboxing) sono configurate separatamente, quindi un dominio che vuoi che un processo in sandbox raggiunga ha ancora bisogno di una regola di autorizzazione sandbox esplicita.

275

276## Comportamento dello strumento WebSearch

277

278WebSearch esegue una query rispetto al backend di [web search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool) di Anthropic e restituisce titoli e URL dei risultati. Non recupera le pagine dei risultati. Per leggere una pagina che Claude trova nei risultati di ricerca, segue con [WebFetch](#webfetch-tool-behavior).

279

280Lo strumento può emettere fino a otto ricerche backend per chiamata, affinando la ricerca internamente prima di restituire i risultati. Claude può limitare i risultati con `allowed_domains` per includere solo determinati host, o `blocked_domains` per escluderli. I due elenchi non possono essere combinati in una singola chiamata.

281

282Il backend di ricerca non è configurabile. Per cercare con un provider diverso, aggiungi un [server MCP](/it/mcp) che espone uno strumento di ricerca.

283

284Le regole di autorizzazione WebSearch non accettano specifier. Una voce `WebSearch` nuda in `allow` o `deny` è l'unica forma.

285

286<Note>

287 WebSearch è disponibile sull'API Claude e su Microsoft Foundry. Su Google Cloud Vertex AI funziona con i modelli Claude 4, inclusi Opus, Sonnet, e Haiku. Amazon Bedrock non espone lo strumento di web search lato server.

288</Note>

289

290## Comportamento dello strumento Write

291

292Lo strumento Write crea un nuovo file o sovrascrivi uno esistente con il contenuto completo fornito. Non aggiunge o unisce.

293

294Se il percorso target esiste già, Claude deve aver letto quel file almeno una volta nella conversazione corrente prima di sovrascriverlo. Una Write a un file esistente non letto fallisce con un errore. Questo vincolo non si applica ai nuovi file.

295

296Visualizzare il file con Bash `cat` o `sed -n` soddisfa anche questo requisito, come descritto in [comportamento dello strumento Edit](#edit-tool-behavior).

297

298Per modifiche parziali a un file esistente, Claude utilizza Edit invece di Write.

299

133## Verifica quali strumenti sono disponibili300## Verifica quali strumenti sono disponibili

134 301

135Il tuo set esatto di strumenti dipende dal tuo provider, dalla piattaforma e dalle impostazioni. Per verificare cosa è caricato in una sessione in esecuzione, chiedi direttamente a Claude:302Il tuo set esatto di strumenti dipende dal tuo provider, dalla piattaforma e dalle impostazioni. Per verificare cosa è caricato in una sessione in esecuzione, chiedi direttamente a Claude:

worktrees.md +161 −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# Eseguire sessioni parallele con worktrees

7> Isolare sessioni parallele di Claude Code in worktrees git separati in modo che i cambiamenti non si scontrino. Copre il flag `--worktree`, l'isolamento dei subagent, `.worktreeinclude`, la pulizia e gli hook VCS non-git.

9Un [git worktree](https://git-scm.com/docs/git-worktree) è una directory di lavoro separata con i propri file e branch, che condivide la stessa cronologia del repository e il remote come il vostro checkout principale. Eseguire ogni sessione di Claude Code nel proprio worktree significa che le modifiche in una sessione non toccheranno mai i file in un'altra, quindi potete avere Claude che costruisce una funzionalità in un terminale mentre corregge un bug in un secondo.

11Questa pagina copre l'isolamento dei worktree nella CLI. Tutto quanto segue presuppone un repository git. Per altri sistemi di controllo versione, vedere [Controllo versione non-git](#non-git-version-control). L'[app desktop](/it/desktop#work-in-parallel-with-sessions) crea un worktree per ogni nuova sessione automaticamente.

13I worktree sono uno dei diversi modi per eseguire Claude in parallelo. Isolano le modifiche ai file, mentre i [subagent](/it/sub-agents) e i [team di agenti](/it/agent-teams) coordinano il lavoro stesso. Vedere [Eseguire agenti in parallelo](/it/agents) per confrontare gli approcci, o saltare direttamente a [Isolare i subagent con worktrees](#isolate-subagents-with-worktrees) per utilizzare worktree e subagent insieme.

15## Avviare Claude in un worktree

17Passate `--worktree` o `-w` per creare un worktree isolato e avviare Claude in esso. Per impostazione predefinita, il worktree viene creato sotto `.claude/worktrees/<value>/` nella radice del vostro repository, su un nuovo branch denominato `worktree-<value>`:

19```bash theme={null}

20claude --worktree feature-auth

21```

23Per mettere i worktree altrove, configurate un hook [`WorktreeCreate`](#non-git-version-control). Eseguite il comando di nuovo con un nome diverso in un altro terminale per avviare una seconda sessione isolata:

25```bash theme={null}

26claude --worktree bugfix-123

27```

29Se omettete il nome, Claude ne genera uno come `bright-running-fox`:

31```bash theme={null}

32claude --worktree

33```

35Potete anche chiedere a Claude di "lavorare in un worktree" durante una sessione, e creerà uno con lo strumento [`EnterWorktree`](/it/tools-reference).

37Prima di utilizzare `--worktree` in una directory per la prima volta, accettate la finestra di dialogo di fiducia dell'area di lavoro eseguendo `claude` una volta in quella directory. Se la fiducia non è stata ancora accettata, `--worktree` esce con un errore e vi chiede di eseguire `claude` nella directory per primo, anche quando combinato con `-p`.

39<Tip>

40 Aggiungete `.claude/worktrees/` al vostro `.gitignore` in modo che i contenuti del worktree non appaiano come file non tracciati nel vostro checkout principale.

41</Tip>

43### Scegliere il branch di base

45I worktree si diramano dal branch predefinito del vostro repository, `origin/HEAD`, quindi iniziano da un albero pulito che corrisponde al remote. Se nessun remote è configurato o il fetch fallisce, il worktree ricade al vostro `HEAD` locale corrente. Per diramarvisi sempre dal `HEAD` locale, impostate `worktree.baseRef` a `"head"` nelle [impostazioni](/it/settings#worktree-settings). Impostare `baseRef` a `"head"` fa sì che i nuovi worktree portino i vostri commit non spinti e lo stato del feature-branch, il che è utile quando si isolano i subagent che devono operare su lavori in corso. L'impostazione accetta solo `"fresh"` o `"head"`, non ref git arbitrari:

47```json theme={null}

48{

49 "worktree": {

50 "baseRef": "head"

51 }

52}

53```

55Per diramarvisi da una pull request specifica, passate il numero della PR con il prefisso `#`, o un URL completo della pull request di GitHub. Claude Code recupera `pull/<number>/head` da `origin` e crea il worktree in `.claude/worktrees/pr-<number>`:

57```bash theme={null}

58claude --worktree "#1234"

59```

61Per il controllo completo su come vengono creati i worktree, configurate un hook [`WorktreeCreate`](/it/hooks#worktreecreate), che sostituisce completamente la logica predefinita di `git worktree`.

63## Copiare file gitignored nei worktrees

65Un worktree è un checkout fresco, quindi i file non tracciati come `.env` o `.env.local` dal vostro repository principale non sono presenti. Per copiarli automaticamente quando Claude crea un worktree, aggiungete un file `.worktreeinclude` alla radice del vostro progetto.

67Il file utilizza la sintassi `.gitignore`. Solo i file che corrispondono a un pattern e sono anche gitignored vengono copiati, quindi i file tracciati non vengono mai duplicati.

69Questo `.worktreeinclude` copia due file env e una configurazione di segreti in ogni nuovo worktree:

71```text .worktreeinclude theme={null}

72.env

73.env.local

74config/secrets.json

75```

77Questo si applica ai worktree creati con `--worktree`, [worktree dei subagent](#isolate-subagents-with-worktrees), e sessioni parallele nell'[app desktop](/it/desktop#work-in-parallel-with-sessions).

79## Isolare i subagent con worktrees

81I subagent possono eseguire nei propri worktree in modo che le modifiche parallele non entrino in conflitto. Chiedete a Claude di "usare worktree per i vostri agenti", o impostatelo permanentemente su un [subagent personalizzato](/it/sub-agents#supported-frontmatter-fields) aggiungendo `isolation: worktree` al frontmatter. Ogni subagent ottiene un worktree temporaneo che viene rimosso automaticamente quando il subagent finisce senza modifiche.

83## Pulire i worktrees

85Quando uscite da una sessione di worktree, la pulizia dipende dal fatto che abbiate apportato modifiche:

87* **Nessuna modifica**: il worktree e il suo branch vengono rimossi automaticamente

88* **Modifiche o commit esistono**: Claude vi chiede di mantenere o rimuovere il worktree. Mantenere preserva la directory e il branch in modo da poter tornare in seguito. Rimuovere elimina la directory del worktree e il suo branch, scartando tutte le modifiche non committate e i commit

89* **Esecuzioni non interattive**: i worktree creati con `--worktree` insieme a `-p` non vengono puliti automaticamente poiché non c'è un prompt di uscita. Rimuoveteli con `git worktree remove`

91I worktree dei subagent orfani da un crash o da un'esecuzione interrotta vengono rimossi all'avvio una volta che sono più vecchi della vostra impostazione [`cleanupPeriodDays`](/it/settings#available-settings), a condizione che non abbiano modifiche non committate, nessun file non tracciato e nessun commit non spinto. I worktree che create con `--worktree` non vengono mai rimossi da questa scansione.

93## Gestire i worktrees manualmente

95Per il controllo completo sulla posizione del worktree e sulla configurazione del branch, create i worktree direttamente con Git. Questo è utile quando dovete controllare un branch esistente specifico o posizionare il worktree al di fuori del repository.

97Create un worktree su un nuovo branch:

99```bash theme={null}

100git worktree add ../project-feature-a -b feature-a

101```

102

103Create un worktree da un branch esistente:

104

105```bash theme={null}

106git worktree add ../project-bugfix bugfix-123

107```

108

109Avviate Claude nel worktree:

110

111```bash theme={null}

112cd ../project-feature-a && claude

113```

114

115Elencate i vostri worktree:

116

117```bash theme={null}

118git worktree list

119```

120

121Rimuovete uno quando avete finito:

122

123```bash theme={null}

124git worktree remove ../project-feature-a

125```

126

127Vedere la [documentazione di Git worktree](https://git-scm.com/docs/git-worktree) per il riferimento completo dei comandi. Ricordate di inizializzare il vostro ambiente di sviluppo in ogni nuovo worktree: installate le dipendenze, configurate gli ambienti virtuali, o eseguite qualunque cosa il vostro progetto richieda.

128

129## Controllo versione non-git

130

131L'isolamento dei worktree utilizza git per impostazione predefinita. Per SVN, Perforce, Mercurial o altri sistemi, configurate gli hook [`WorktreeCreate` e `WorktreeRemove`](/it/hooks#worktreecreate) per fornire logica di creazione e pulizia personalizzata. Poiché l'hook sostituisce il comportamento predefinito di git, [`.worktreeinclude`](#copy-gitignored-files-into-worktrees) non viene elaborato quando utilizzate `--worktree`. Copiate i file di configurazione locali all'interno dello script dell'hook.

132

133Questo hook `WorktreeCreate` legge il nome del worktree da stdin, controlla una copia di lavoro SVN fresca, e stampa il percorso della directory in modo che Claude Code possa usarlo come directory di lavoro della sessione:

134

135```json theme={null}

136{

137 "hooks": {

138 "WorktreeCreate": [

139 {

140 "hooks": [

141 {

142 "type": "command",

143 "command": "bash -c 'NAME=$(jq -r .name); DIR=\"$HOME/.claude/worktrees/$NAME\"; svn checkout https://svn.example.com/repo/trunk \"$DIR\" >&2 && echo \"$DIR\"'"

144 }

145 ]

146 }

147 ]

148 }

149}

150```

151

152Abbinarlo a un hook `WorktreeRemove` per pulire quando la sessione termina. Vedere il [riferimento degli hook](/it/hooks#worktreecreate) per lo schema di input e un esempio di rimozione.

153

154## Vedere anche

155

156I worktree gestiscono l'isolamento dei file. Le pagine correlate di seguito coprono la delega del lavoro in quei checkout isolati e il passaggio tra le sessioni che create:

157

158* [Subagent](/it/sub-agents): delegare il lavoro ad agenti isolati all'interno di una sessione

159* [Team di agenti](/it/agent-teams): coordinare più sessioni di Claude automaticamente

160* [Gestire le sessioni](/it/sessions): nominare, riprendere e passare tra conversazioni

161* [Sessioni parallele desktop](/it/desktop#work-in-parallel-with-sessions): sessioni supportate da worktree nell'app desktop

Documentation 2026-05-10 23:03 UTC to 2026-05-11 23:00 UTC