cc-viewer 1.6.182 → 1.6.183

package/concepts/it/Tool-Skill.md

@@ -1,56 +1,47 @@
 # Skill
 
-## Definizione
+Invoca una skill nominata all'interno della conversazione corrente. Le skill sono bundle di capacità pre-confezionati — conoscenza di dominio, workflow e a volte accesso a tool — che l'harness espone all'assistente tramite avvisi di sistema.
 
-Esegue una skill (abilità) nella conversazione principale. Le skill sono capacità specializzate che l'utente può invocare tramite slash command (es. `/commit`, `/review-pr`).
+## Quando usare
 
-## Parametri
+- L'utente digita un comando slash come `/review` o `/init` — i comandi slash sono skill e devono essere eseguiti tramite questo tool.
+- L'utente descrive un compito che corrisponde alle condizioni di attivazione di una skill pubblicizzata (ad esempio, chiedere di scansionare i transcript per prompt di permessi ripetuti corrisponde a `fewer-permission-prompts`).
+- Lo scopo dichiarato di una skill corrisponde direttamente al file corrente, alla richiesta o al contesto della conversazione.
+- Workflow specializzati e ripetibili sono disponibili come skill e la procedura canonica è preferibile a un approccio ad hoc.
+- L'utente chiede "quali skill sono disponibili" — elenca i nomi pubblicizzati e invoca solo quando confermano.
 
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `skill` | string | Sì | Nome della skill (es. "commit", "review-pr", "pdf") |
-| `args` | string | No | Argomenti della skill |
+## Parametri
 
-## Scenari d'uso
+- `skill` (string, obbligatorio): Il nome esatto di una skill elencata nell'avviso di sistema delle skill disponibili corrente. Per le skill con namespace di plugin, usa la forma completa `plugin:skill` (ad esempio `skill-creator:skill-creator`). Non includere uno slash iniziale.
+- `args` (string, opzionale): Argomenti a forma libera passati alla skill. Formato e semantica sono definiti dalla documentazione di ciascuna skill.
 
-**Adatto per:**
-- L'utente ha inserito uno slash command nel formato `/<skill-name>`
-- La richiesta dell'utente corrisponde alla funzionalità di una skill registrata
+## Esempi
 
-**Non adatto per:**
-- Comandi CLI integrati (es. `/help`, `/clear`)
-- Una skill già in esecuzione
-- Nomi di skill non presenti nella lista delle skill disponibili
+### Esempio 1: Eseguire una skill di review sul branch corrente
 
-## Note
+```
+Skill(skill="review")
+```
 
-- Dopo l'invocazione, la skill viene espansa in un prompt completo
-- Supporta nomi completamente qualificati (es. `ms-office-suite:pdf`)
-- La lista delle skill disponibili è fornita nei messaggi system-reminder
-- Quando si vede un tag `<command-name>`, significa che la skill è stata caricata e va eseguita direttamente senza richiamare nuovamente questo strumento
-- Non menzionare una skill senza aver effettivamente invocato lo strumento
+La skill `review` impacchetta i passi per revisionare una pull request rispetto al branch di base corrente. Invocarla carica la procedura di review definita dall'harness nel turno.
 
-## Testo originale
+### Esempio 2: Invocare una skill con namespace di plugin con argomenti
 
-<textarea readonly>Execute a skill within the main conversation
+```
+Skill(
+  skill="skill-creator:skill-creator",
+  args="create a skill that summarizes git log for a given date range"
+)
+```
 
-When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+Instrada la richiesta attraverso il punto di ingresso del plugin `skill-creator` così che il workflow di creazione si attivi.
 
-When users reference a "slash command" or "/<something>" (e.g., "/commit", "/review-pr"), they are referring to a skill. Use this tool to invoke it.
-
-How to invoke:
-- Use this tool with the skill name and optional arguments
-- Examples:
-  - `skill: "pdf"` - invoke the pdf skill
-  - `skill: "commit", args: "-m 'Fix bug'"` - invoke with arguments
-  - `skill: "review-pr", args: "123"` - invoke with arguments
-  - `skill: "ms-office-suite:pdf"` - invoke using fully qualified name
+## Note
 
-Important:
-- Available skills are listed in system-reminder messages in the conversation
-- When a skill matches the user's request, this is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
-- NEVER mention a skill without actually calling this tool
-- Do not invoke a skill that is already running
-- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
-- If you see a <command-name> tag in the current conversation turn, the skill has ALREADY been loaded - follow the instructions directly instead of calling this tool again
-</textarea>
+- Invoca solo skill i cui nomi appaiono verbatim nell'avviso di sistema delle skill disponibili, o skill che l'utente ha digitato direttamente come `/name` nel suo messaggio. Non indovinare o inventare nomi di skill dalla memoria o dai dati di addestramento — se la skill non è pubblicizzata, non chiamare questo tool.
+- Quando una richiesta dell'utente corrisponde a una skill pubblicizzata, chiamare `Skill` è un prerequisito bloccante: invocala prima di generare qualsiasi altra risposta sul compito. Non descrivere cosa farebbe la skill — eseguila.
+- Non menzionare mai una skill per nome senza effettivamente invocarla. Annunciare una skill senza chiamare il tool è fuorviante.
+- Non usare `Skill` per comandi CLI integrati come `/help`, `/clear`, `/model` o `/exit`. Quelli sono gestiti direttamente dall'harness.
+- Non re-invocare una skill già in esecuzione nel turno corrente. Se vedi un tag `<command-name>` nel turno corrente, la skill è già stata caricata — segui le sue istruzioni in loco invece di chiamare nuovamente il tool.
+- Se più skill potrebbero applicarsi, scegli quella più specifica. Per modifiche di configurazione come aggiungere permessi o hook, preferisci `update-config` a un approccio generico alle impostazioni.
+- L'esecuzione di una skill può introdurre nuovi avvisi di sistema, tool o vincoli per il resto del turno. Rileggi lo stato della conversazione dopo che una skill è completata prima di procedere.

package/concepts/it/Tool-TaskCreate.md

@@ -1,78 +1,56 @@
 # TaskCreate
 
-## Definizione
+Crea un nuovo task nella lista dei task del team corrente (o nella lista dei task della sessione quando nessun team è attivo). Usalo per catturare voci di lavoro che dovrebbero essere tracciate, delegate o riconsiderate in seguito.
 
-Crea una voce strutturata nella lista dei task, per tracciare i progressi, organizzare task complessi e mostrare all'utente l'avanzamento del lavoro.
+## Quando usare
 
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `subject` | string | Sì | Breve titolo del task, in forma imperativa (es. "Fix authentication bug") |
-| `description` | string | Sì | Descrizione dettagliata, inclusi contesto e criteri di accettazione |
-| `activeForm` | string | No | Testo al presente progressivo mostrato durante l'esecuzione (es. "Fixing authentication bug") |
-| `metadata` | object | No | Metadati arbitrari allegati al task |
-
-## Scenari d'uso
-
-**Adatto per:**
-- Task complessi multi-step (più di 3 step)
-- L'utente ha fornito più elementi da fare
-- Tracciamento del lavoro in modalità pianificazione
-- L'utente richiede esplicitamente l'uso di una lista todo
-
-**Non adatto per:**
-- Un singolo task semplice
-- Operazioni semplici con meno di 3 step
-- Conversazioni pure o richieste informative
+- L'utente descrive un pezzo di lavoro a più passi che beneficia di un tracciamento esplicito.
+- Stai scomponendo una richiesta grande in unità più piccole, separatamente completabili.
+- Un follow-up viene scoperto durante un compito e non dovrebbe essere dimenticato.
+- Hai bisogno di un record duraturo di intento prima di passare il lavoro a un teammate o subagente.
+- Stai operando in plan mode e vuoi che ogni passo del piano sia rappresentato come un task concreto.
 
-## Note
-
-- Tutti i task appena creati hanno stato iniziale `pending`
-- `subject` usa la forma imperativa ("Run tests"), `activeForm` usa il presente progressivo ("Running tests")
-- Dopo la creazione, è possibile impostare le dipendenze (blocks/blockedBy) tramite TaskUpdate
-- Prima di creare, verificare con TaskList se esistono task duplicati
-
-## Testo originale
+Salta `TaskCreate` per azioni banali one-shot, pura conversazione o qualsiasi cosa completabile in due o tre chiamate tool dirette.
 
-<textarea readonly>Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
+## Parametri
 
-## When to Use This Tool
+- `subject` (string, obbligatorio): Titolo imperativo breve, ad esempio `Fix login redirect on Safari`. Mantienilo sotto circa ottanta caratteri.
+- `description` (string, obbligatorio): Contesto dettagliato — il problema, i vincoli, i criteri di accettazione e qualsiasi file o link di cui un futuro lettore avrà bisogno. Scrivi come se un teammate lo raccogliesse a freddo.
+- `activeForm` (string, opzionale): Testo spinner al presente continuo mostrato mentre il task è `in_progress`, ad esempio `Fixing login redirect on Safari`. Rispecchia il `subject` ma in forma -ing.
+- `metadata` (object, opzionale): Dati strutturati arbitrari allegati al task. Usi comuni: etichette, suggerimenti di priorità, ID di ticket esterni o configurazione specifica dell'agente.
 
-Use this tool proactively in these scenarios:
+I task appena creati iniziano sempre con stato `pending` e senza proprietario. Le dipendenze (`blocks`, `blockedBy`) non sono impostate al momento della creazione — applicale successivamente con `TaskUpdate`.
 
-- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-- Plan mode - When using plan mode, create a task list to track the work
-- User explicitly requests todo list - When the user directly asks you to use the todo list
-- User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-- After receiving new instructions - Immediately capture user requirements as tasks
-- When you start working on a task - Mark it as in_progress BEFORE beginning work
-- After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+## Esempi
 
-## When NOT to Use This Tool
+### Esempio 1
 
-Skip using this tool when:
-- There is only a single, straightforward task
-- The task is trivial and tracking it provides no organizational benefit
-- The task can be completed in less than 3 trivial steps
-- The task is purely conversational or informational
+Cattura una segnalazione bug che l'utente ha appena presentato.
 
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+```
+TaskCreate(
+  subject: "Repair broken PDF export on Windows",
+  description: "Users on Windows 11 report the export button produces a 0-byte file. Reproduce with sample doc in test/fixtures/export/, then fix the code path in src/export/pdf.ts. Acceptance: export writes a valid PDF and the existing export test suite passes.",
+  activeForm: "Repairing broken PDF export on Windows"
+)
+```
 
-## Task Fields
+### Esempio 2
 
-- **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
-- **description**: Detailed description of what needs to be done, including context and acceptance criteria
-- **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
+Dividi un epic in unità tracciate all'inizio di una sessione.
 
-**IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status `pending`.
+```
+TaskCreate(
+  subject: "Draft migration plan for auth service",
+  description: "Produce a written plan covering rollout stages, rollback strategy, and monitoring. Output: docs/auth-migration.md.",
+  activeForm: "Drafting migration plan for auth service",
+  metadata: { "priority": "P1", "linearId": "AUTH-214" }
+)
+```
 
-## Tips
+## Note
 
-- Create tasks with clear, specific subjects that describe the outcome
-- Include enough detail in the description for another agent to understand and complete the task
-- After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
-- Check TaskList first to avoid creating duplicate tasks
-</textarea>
+- Scrivi il `subject` in voce imperativa e l'`activeForm` al presente continuo così che l'UI si legga naturalmente quando il task transita a `in_progress`.
+- Chiama `TaskList` prima di creare per evitare duplicati — la lista del team è condivisa con teammate e subagenti.
+- Non includere segreti o credenziali in `description` o `metadata`; i record dei task sono visibili a chiunque abbia accesso al team.
+- Dopo la creazione, muovi il task attraverso il suo ciclo di vita con `TaskUpdate`. Non lasciare il lavoro silenziosamente abbandonato in `in_progress`.

package/concepts/it/Tool-TaskGet.md

@@ -1,56 +1,47 @@
 # TaskGet
 
-## Definizione
+Recupera il record completo per un singolo task tramite ID, inclusa la sua descrizione, stato corrente, proprietario, metadati e archi di dipendenza. Usalo quando il riepilogo restituito da `TaskList` non è sufficiente per agire sul task.
 
-Ottiene i dettagli completi di un task tramite il suo ID.
+## Quando usare
 
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `taskId` | string | Sì | ID del task da ottenere |
-
-## Contenuto restituito
+- Hai preso un task da `TaskList` e hai bisogno della descrizione completa prima di iniziare il lavoro.
+- Stai per marcare un task come `completed` e vuoi ricontrollare i criteri di accettazione.
+- Devi ispezionare quali task questo `blocks` o è `blockedBy` per decidere la mossa successiva.
+- Stai indagando la storia — chi lo possiede, quali metadati sono stati allegati, quando ha cambiato stato.
+- Un teammate o una sessione precedente ha fatto riferimento a un ID task e ti serve il contesto.
 
-- `subject` — Titolo del task
-- `description` — Requisiti dettagliati e contesto
-- `status` — Stato: `pending`, `in_progress` o `completed`
-- `blocks` — Lista dei task bloccati da questo task
-- `blockedBy` — Lista dei task prerequisiti che bloccano questo task
+Preferisci `TaskList` quando hai solo bisogno di una scansione ad alto livello; riserva `TaskGet` al record specifico che intendi leggere attentamente o modificare.
 
-## Scenari d'uso
+## Parametri
 
-**Adatto per:**
-- Ottenere la descrizione completa e il contesto di un task prima di iniziare il lavoro
-- Comprendere le dipendenze del task
-- Ottenere i requisiti completi dopo essere stati assegnati a un task
+- `taskId` (string, obbligatorio): L'identificatore del task restituito da `TaskCreate` o `TaskList`. Gli ID sono stabili per tutta la vita del task.
 
-## Note
+## Esempi
 
-- Dopo aver ottenuto il task, verificare che la lista `blockedBy` sia vuota prima di iniziare il lavoro
-- Usare TaskList per visualizzare il riepilogo di tutti i task
+### Esempio 1
 
-## Testo originale
+Cerca un task che hai appena visto nella lista.
 
-<textarea readonly>Use this tool to retrieve a task by its ID from the task list.
+```
+TaskGet(taskId: "t_01HXYZ...")
+```
 
-## When to Use This Tool
+Campi di risposta tipici: `id`, `subject`, `description`, `activeForm`, `status`, `owner`, `blocks`, `blockedBy`, `metadata`, `createdAt`, `updatedAt`.
 
-- When you need the full description and context before starting work on a task
-- To understand task dependencies (what it blocks, what blocks it)
-- After being assigned a task, to get complete requirements
+### Esempio 2
 
-## Output
+Risolvi le dipendenze prima di iniziare.
 
-Returns full task details:
-- **subject**: Task title
-- **description**: Detailed requirements and context
-- **status**: 'pending', 'in_progress', or 'completed'
-- **blocks**: Tasks waiting on this one to complete
-- **blockedBy**: Tasks that must complete before this one can start
+```
+TaskGet(taskId: "t_01HXYZ...")
+# Ispeziona blockedBy — se qualsiasi task referenziato è ancora pending
+# o in_progress, lavora prima sul blocker.
+```
 
-## Tips
+## Note
 
-- After fetching a task, verify its blockedBy list is empty before beginning work.
-- Use TaskList to see all tasks in summary form.
-</textarea>
+- `TaskGet` è in sola lettura ed è sicuro chiamarlo ripetutamente; non cambia lo stato o la proprietà.
+- Se `blockedBy` non è vuoto e contiene task che non sono `completed`, non iniziare questo task — risolvi prima i blocker (o coordinati con il loro proprietario).
+- Il campo `description` può essere lungo. Leggilo per intero prima di agire; scorrere velocemente porta a criteri di accettazione mancati.
+- Un `taskId` sconosciuto o cancellato restituisce un errore. Ri-esegui `TaskList` per scegliere un ID corrente.
+- Se stai per modificare un task, chiama prima `TaskGet` per evitare di sovrascrivere campi che un teammate ha appena cambiato.

package/concepts/it/Tool-TaskList.md

@@ -1,56 +1,63 @@
 # TaskList
 
-## Definizione
+Restituisce ogni task nel team corrente (o sessione) in forma riassuntiva. Usalo per esaminare il lavoro in sospeso, decidere cosa prendere in carico successivamente ed evitare di creare duplicati.
 
-Elenca tutti i task nella lista dei task, per visualizzare i progressi complessivi e il lavoro disponibile.
+## Quando usare
+
+- All'inizio di una sessione per vedere cosa è già tracciato.
+- Prima di chiamare `TaskCreate`, per confermare che il lavoro non sia già catturato.
+- Quando decidi quale task rivendicare successivamente come teammate o subagente.
+- Per verificare le relazioni di dipendenza attraverso il team a colpo d'occhio.
+- Periodicamente durante sessioni lunghe per risincronizzarsi con i teammate che potrebbero aver rivendicato, completato o aggiunto task.
+
+`TaskList` è in sola lettura ed economico; chiamalo liberamente ogni volta che hai bisogno di una panoramica.
 
 ## Parametri
 
-Nessun parametro.
+`TaskList` non accetta parametri. Restituisce sempre l'insieme completo dei task per il contesto attivo.
 
-## Contenuto restituito
+## Forma della risposta
 
-Informazioni di riepilogo per ogni task:
-- `id` — Identificatore del task
-- `subject` — Breve descrizione
-- `status` — Stato: `pending`, `in_progress` o `completed`
-- `owner` — Responsabile (agent ID), vuoto se non assegnato
-- `blockedBy` — Lista degli ID dei task non completati che bloccano questo task
+Ogni task nella lista è un riepilogo, non il record completo. Attendi approssimativamente:
 
-## Scenari d'uso
+- `id` — identificatore stabile da usare con `TaskGet` / `TaskUpdate`.
+- `subject` — titolo imperativo breve.
+- `status` — uno tra `pending`, `in_progress`, `completed`, `deleted`.
+- `owner` — handle di agente o teammate, o vuoto quando non rivendicato.
+- `blockedBy` — array di ID task che devono completarsi prima.
 
-**Adatto per:**
-- Vedere quali task sono disponibili (stato pending, senza owner, non bloccati)
-- Controllare i progressi complessivi del progetto
-- Trovare task bloccati
-- Trovare il prossimo task dopo averne completato uno
+Per la descrizione completa, i criteri di accettazione o i metadati di un task specifico, segui con `TaskGet`.
 
-## Note
+## Esempi
 
-- Elaborare i task preferibilmente in ordine di ID (ID più basso per primo), poiché i task precedenti forniscono tipicamente contesto per quelli successivi
-- I task con `blockedBy` non possono essere presi in carico finché le dipendenze non sono risolte
-- Usare TaskGet per ottenere i dettagli completi di un task specifico
+### Esempio 1
 
-## Testo originale
+Controllo rapido dello stato.
 
-<textarea readonly>Use this tool to list all tasks in the task list.
+```
+TaskList()
+```
 
-## When to Use This Tool
+Scansiona l'output per qualsiasi cosa `in_progress` senza un `owner` (lavoro stantio) e qualsiasi cosa `pending` con `blockedBy` vuoto (pronto da prendere).
 
-- To see what tasks are available to work on (status: 'pending', no owner, not blocked)
-- To check overall progress on the project
-- To find tasks that are blocked and need dependencies resolved
-- After completing a task, to check for newly unblocked work or claim the next available task
-- **Prefer working on tasks in ID order** (lowest ID first) when multiple tasks are available, as earlier tasks often set up context for later ones
+### Esempio 2
 
-## Output
+Teammate che sceglie il prossimo task.
 
-Returns a summary of each task:
-- **id**: Task identifier (use with TaskGet, TaskUpdate)
-- **subject**: Brief description of the task
-- **status**: 'pending', 'in_progress', or 'completed'
-- **owner**: Agent ID if assigned, empty if available
-- **blockedBy**: List of open task IDs that must be resolved first (tasks with blockedBy cannot be claimed until dependencies resolve)
+```
+TaskList()
+# Filtra a: status == pending AND blockedBy è vuoto AND owner è vuoto.
+# Tra questi, preferisci l'ID più basso (i task sono tipicamente numerati in
+# ordine di creazione, quindi gli ID più bassi sono più vecchi e di solito
+# di priorità più alta).
+TaskGet(taskId: "<chosen id>")
+TaskUpdate(taskId: "<chosen id>", status: "in_progress", owner: "<your handle>")
+```
+
+## Note
 
-Use TaskGet with a specific task ID to view full details including description and comments.
-</textarea>
+- Euristica teammate: quando più task `pending` sono sbloccati e senza proprietario, scegli l'ID più basso. Questo mantiene il lavoro FIFO ed evita che due agenti afferrino lo stesso task di alto profilo.
+- Rispetta `blockedBy`: non iniziare un task i cui blocker sono ancora `pending` o `in_progress`. Lavora prima sul blocker o coordinati con il suo proprietario.
+- `TaskList` è l'unico meccanismo di scoperta per i task. Non esiste ricerca; se la lista è lunga, scansiona strutturalmente (per stato, poi per proprietario).
+- I task eliminati possono ancora apparire nella lista con stato `deleted` per tracciabilità. Ignorali per scopi di pianificazione.
+- La lista riflette lo stato live del team, quindi i teammate possono aggiungere o rivendicare task tra le chiamate. Rielenca prima di rivendicare se è passato del tempo.

package/concepts/it/Tool-TaskOutput.md

@@ -1,40 +1,50 @@
 # TaskOutput
 
-## Definizione
+Recupera l'output accumulato di un task in background in esecuzione o completato — un comando shell in background, un agente locale o una sessione remota. Usalo quando devi ispezionare ciò che un task a lunga esecuzione ha prodotto finora.
 
-Ottiene l'output di un task in background in esecuzione o completato. Applicabile a shell in background, agent asincroni e sessioni remote.
+## Quando usare
+
+- Una sessione remota (ad esempio una sandbox cloud) è in esecuzione e ti serve il suo stdout.
+- Un agente locale è stato inviato in background e vuoi progressi parziali prima che ritorni.
+- Un comando shell in background è in esecuzione da abbastanza tempo che vuoi controllarlo senza fermarlo.
+- Devi confermare che un task in background stia effettivamente facendo progressi prima di aspettare ulteriormente o chiamare `TaskStop`.
+
+Non ricorrere a `TaskOutput` riflessivamente. Per la maggior parte del lavoro in background c'è un percorso più diretto — vedi le note sotto.
 
 ## Parametri
 
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `task_id` | string | Sì | ID del task |
-| `block` | boolean | Sì | Se attendere in modo bloccante il completamento del task, predefinito `true` |
-| `timeout` | number | Sì | Tempo massimo di attesa (millisecondi), predefinito 30000, massimo 600000 |
+- `task_id` (string, obbligatorio): L'identificatore del task restituito quando il lavoro in background è stato avviato. Non è lo stesso di un `taskId` della task-list; questo è l'handle di runtime per l'esecuzione specifica.
+- `block` (boolean, opzionale): Quando `true` (default), attende che il task produca nuovo output o termini prima di restituire. Quando `false`, restituisce immediatamente con qualsiasi cosa sia bufferizzata.
+- `timeout` (number, opzionale): Millisecondi massimi da bloccare prima di restituire. Significativo solo quando `block` è `true`. Default `30000`, massimo `600000`.
 
-## Scenari d'uso
+## Esempi
 
-**Adatto per:**
-- Controllare i progressi di un agent in background avviato tramite Task (`run_in_background: true`)
-- Ottenere i risultati dell'esecuzione di comandi Bash in background
-- Attendere il completamento di un task asincrono e ottenerne l'output
+### Esempio 1
 
-**Non adatto per:**
-- Task in primo piano — i task in primo piano restituiscono direttamente i risultati, questo strumento non è necessario
+Sbircia una sessione remota senza bloccare.
 
-## Note
+```
+TaskOutput(task_id: "sess_01HXYZ...", block: false)
+```
+
+Restituisce qualsiasi stdout/stderr prodotto da quando il task è iniziato (o dalla tua ultima chiamata `TaskOutput`, a seconda del runtime).
 
-- `block: true` blocca fino al completamento del task o al timeout
-- `block: false` per un controllo non bloccante dello stato corrente
-- L'ID del task può essere trovato tramite il comando `/tasks`
-- Applicabile a tutti i tipi di task: shell in background, agent asincroni, sessioni remote
+### Esempio 2
 
-## Testo originale
+Aspetta brevemente che un agente locale emetta più output.
+
+```
+TaskOutput(
+  task_id: "agent_01ABCD...",
+  block: true,
+  timeout: 10000
+)
+```
+
+## Note
 
-<textarea readonly>- Retrieves output from a running or completed task (background shell, agent, or remote session)
-- Takes a task_id parameter identifying the task
-- Returns the task output along with status information
-- Use block=true (default) to wait for task completion
-- Use block=false for non-blocking check of current status
-- Task IDs can be found using the /tasks command
-- Works with all task types: background shells, async agents, and remote sessions</textarea>
+- Comandi bash in background: `TaskOutput` è di fatto deprecato per questo caso d'uso. Quando avvii un task shell in background il risultato include già il percorso al suo file di output — leggi quel percorso direttamente con il tool `Read`. `Read` ti dà accesso casuale, offset di riga e una vista stabile; `TaskOutput` no.
+- Agenti locali (il tool `Agent` inviato in background): quando l'agente finisce, il risultato del tool `Agent` contiene già la sua risposta finale. Usalo direttamente. Non fare `Read` sul file transcript simlinkato — contiene l'intero flusso di tool-call e farà overflow della finestra di contesto.
+- Sessioni remote: `TaskOutput` è il modo corretto e spesso unico per fare streaming dell'output. Preferisci `block: true` con un `timeout` modesto a loop di polling stretti.
+- Un `task_id` sconosciuto, o un task il cui output è stato garbage-collectato, restituisce un errore. Ri-invia il lavoro se ne hai ancora bisogno.
+- `TaskOutput` non ferma il task. Usa `TaskStop` per terminare.

package/concepts/it/Tool-TaskStop.md

@@ -1,32 +1,45 @@
 # TaskStop
 
-## Definizione
+Ferma un task in background in esecuzione — un comando shell, un agente inviato o una sessione remota — tramite il suo handle di runtime. Usalo per liberare risorse, annullare lavoro che non è più utile o recuperare quando un task è bloccato.
 
-Ferma un task in background in esecuzione.
+## Quando usare
+
+- Un comando shell in background è in esecuzione più a lungo del previsto e non ti serve più il suo risultato.
+- Un agente locale è in loop o in stallo e deve essere interrotto.
+- L'utente ha cambiato direzione e il lavoro in background per la direzione precedente dovrebbe essere abbandonato.
+- Una sessione remota sta per andare in timeout o sta trattenendo una risorsa di cui hai bisogno.
+- Hai bisogno di una lavagna pulita prima di avviare una nuova esecuzione dello stesso task.
+
+Preferisci lasciare che il lavoro in background di breve durata finisca da solo. `TaskStop` è per casi in cui l'esecuzione continuata non ha valore o è attivamente dannosa.
 
 ## Parametri
 
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `task_id` | string | No | ID del task in background da fermare |
-| `shell_id` | string | No | Deprecato, usare `task_id` al suo posto |
+- `task_id` (string, obbligatorio): L'handle di runtime restituito quando il task in background è stato avviato. È lo stesso identificatore accettato da `TaskOutput`, non un `taskId` della task-list.
 
-## Scenari d'uso
+## Esempi
 
-**Adatto per:**
-- Terminare task a lunga esecuzione non più necessari
-- Annullare task in background avviati per errore
+### Esempio 1
 
-## Note
+Ferma un comando shell in background che è fuori controllo.
+
+```
+TaskStop(task_id: "bash_01HXYZ...")
+```
 
-- Restituisce uno stato di successo o fallimento
-- Il parametro `shell_id` è deprecato, usare `task_id`
+Il comando riceve un segnale di terminazione; l'output bufferizzato scritto finora resta leggibile al suo percorso di output.
 
-## Testo originale
+### Esempio 2
+
+Annulla un agente inviato dopo una correzione di rotta dell'utente.
+
+```
+TaskStop(task_id: "agent_01ABCD...")
+```
+
+## Note
 
-<textarea readonly>
-- Stops a running background task by its ID
-- Takes a task_id parameter identifying the task to stop
-- Returns a success or failure status
-- Use this tool when you need to terminate a long-running task
-</textarea>
+- `TaskStop` richiede la terminazione; non garantisce spegnimento istantaneo. I task ben comportati escono prontamente, ma un processo che fa I/O bloccante potrebbe impiegare un momento per disattivarsi.
+- Fermare un task non elimina il suo output. Per task shell in background, il file di output su disco è preservato e ancora leggibile con `Read`. Per agenti e sessioni, qualunque output sia stato catturato prima dello stop è ancora accessibile via `TaskOutput`.
+- Un `task_id` sconosciuto, o un task già terminato, restituisce un errore o un no-op. È sicuro — puoi chiamare `TaskStop` difensivamente senza controllare prima lo stato.
+- Se intendi riavviare lo stesso lavoro, ferma il vecchio task prima di inviare quello nuovo per evitare che due esecuzioni parallele competano su risorse condivise (file, porte, righe di database).
+- `TaskStop` non influisce sulle voci nella lista dei task del team. Per annullare un task tracciato, aggiorna il suo stato a `deleted` con `TaskUpdate`.