cx-viewer 1.0.2 → 1.0.4

package/concepts/it/Tool-EnterPlanMode.md

@@ -1,128 +0,0 @@
-# EnterPlanMode
-
-## Definizione
-
-Passa Claude Code alla modalità pianificazione, utilizzata per esplorare il codebase e progettare un piano prima dell'implementazione.
-
-## Parametri
-
-Nessun parametro.
-
-## Scenari d'uso
-
-**Adatto per:**
-- Implementazione di nuove funzionalità — richiede decisioni architetturali
-- Esistono più approcci possibili — richiede la scelta dell'utente
-- Le modifiche al codice influenzano il comportamento o la struttura esistente
-- Modifiche multi-file — potenzialmente coinvolgono 2-3 o più file
-- Requisiti poco chiari — necessario esplorare prima di comprendere l'ambito
-- Le preferenze dell'utente sono importanti — l'implementazione può avere più direzioni ragionevoli
-
-**Non adatto per:**
-- Correzioni di una o poche righe (errori di battitura, bug evidenti)
-- L'utente ha fornito istruzioni molto specifiche
-- Task puramente di ricerca/esplorazione — usare Task (tipo Explore)
-
-## Comportamento in modalità pianificazione
-
-Dopo l'ingresso in modalità pianificazione, Claude Code:
-1. Usa gli strumenti Glob, Grep, Read per esplorare in profondità il codebase
-2. Comprende i pattern e l'architettura esistenti
-3. Progetta il piano di implementazione
-4. Sottopone il piano all'approvazione dell'utente
-5. Se necessario, usa AskUserQuestion per chiarimenti
-6. Quando il piano è pronto, esce tramite ExitPlanMode
-
-## Note
-
-- Questo strumento richiede il consenso dell'utente per entrare in modalità pianificazione
-- In caso di dubbio sulla necessità di pianificare, preferire la pianificazione — allinearsi in anticipo è meglio che rifare il lavoro
-
-## Testo originale
-
-<textarea readonly>Use this tool proactively when you're about to start a non-trivial implementation task. Getting user sign-off on your approach before writing code prevents wasted effort and ensures alignment. This tool transitions you into plan mode where you can explore the codebase and design an implementation approach for user approval.
-
-## When to Use This Tool
-
-**Prefer using EnterPlanMode** for implementation tasks unless they're simple. Use it when ANY of these conditions apply:
-
-1. **New Feature Implementation**: Adding meaningful new functionality
-   - Example: "Add a logout button" - where should it go? What should happen on click?
-   - Example: "Add form validation" - what rules? What error messages?
-
-2. **Multiple Valid Approaches**: The task can be solved in several different ways
-   - Example: "Add caching to the API" - could use Redis, in-memory, file-based, etc.
-   - Example: "Improve performance" - many optimization strategies possible
-
-3. **Code Modifications**: Changes that affect existing behavior or structure
-   - Example: "Update the login flow" - what exactly should change?
-   - Example: "Refactor this component" - what's the target architecture?
-
-4. **Architectural Decisions**: The task requires choosing between patterns or technologies
-   - Example: "Add real-time updates" - WebSockets vs SSE vs polling
-   - Example: "Implement state management" - Redux vs Context vs custom solution
-
-5. **Multi-File Changes**: The task will likely touch more than 2-3 files
-   - Example: "Refactor the authentication system"
-   - Example: "Add a new API endpoint with tests"
-
-6. **Unclear Requirements**: You need to explore before understanding the full scope
-   - Example: "Make the app faster" - need to profile and identify bottlenecks
-   - Example: "Fix the bug in checkout" - need to investigate root cause
-
-7. **User Preferences Matter**: The implementation could reasonably go multiple ways
-   - If you would use AskUserQuestion to clarify the approach, use EnterPlanMode instead
-   - Plan mode lets you explore first, then present options with context
-
-## When NOT to Use This Tool
-
-Only skip EnterPlanMode for simple tasks:
-- Single-line or few-line fixes (typos, obvious bugs, small tweaks)
-- Adding a single function with clear requirements
-- Tasks where the user has given very specific, detailed instructions
-- Pure research/exploration tasks (use the Agent tool with explore agent instead)
-
-## What Happens in Plan Mode
-
-In plan mode, you'll:
-1. Thoroughly explore the codebase using Glob, Grep, and Read tools
-2. Understand existing patterns and architecture
-3. Design an implementation approach
-4. Present your plan to the user for approval
-5. Use AskUserQuestion if you need to clarify approaches
-6. Exit plan mode with ExitPlanMode when ready to implement
-
-## Examples
-
-### GOOD - Use EnterPlanMode:
-User: "Add user authentication to the app"
-- Requires architectural decisions (session vs JWT, where to store tokens, middleware structure)
-
-User: "Optimize the database queries"
-- Multiple approaches possible, need to profile first, significant impact
-
-User: "Implement dark mode"
-- Architectural decision on theme system, affects many components
-
-User: "Add a delete button to the user profile"
-- Seems simple but involves: where to place it, confirmation dialog, API call, error handling, state updates
-
-User: "Update the error handling in the API"
-- Affects multiple files, user should approve the approach
-
-### BAD - Don't use EnterPlanMode:
-User: "Fix the typo in the README"
-- Straightforward, no planning needed
-
-User: "Add a console.log to debug this function"
-- Simple, obvious implementation
-
-User: "What files handle routing?"
-- Research task, not implementation planning
-
-## Important Notes
-
-- This tool REQUIRES user approval - they must consent to entering plan mode
-- If unsure whether to use it, err on the side of planning - it's better to get alignment upfront than to redo work
-- Users appreciate being consulted before significant changes are made to their codebase
-</textarea>

package/concepts/it/Tool-EnterWorktree.md

@@ -1,56 +0,0 @@
-# EnterWorktree
-
-## Definizione
-
-Creates an isolated git worktree and switches the current session into it. Only used when the user explicitly asks to work in a worktree.
-
-## Parametri
-
-| Name | Type | Required | Description |
-|---|---|---|---|
-| name | string | No | A name for the worktree. If not provided, a random name is generated. |
-
-## Casi d'uso
-
-**Adatto per:**
-- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree")
-
-**Non adatto per:**
-- The user asks to create/switch branches — use git commands instead
-- The user asks to fix a bug or work on a feature — use normal git workflow unless they specifically mention worktrees
-
-## Note
-
-- Must be in a git repository, or have WorktreeCreate/WorktreeRemove hooks configured
-- Must not already be in a worktree
-
-## Testo originale
-
-<textarea readonly>Use this tool ONLY when the user explicitly asks to work in a worktree. This tool creates an isolated git worktree and switches the current session into it.
-
-## When to Use
-
-- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree", "use a worktree")
-
-## When NOT to Use
-
-- The user asks to create a branch, switch branches, or work on a different branch — use git commands instead
-- The user asks to fix a bug or work on a feature — use normal git workflow unless they specifically mention worktrees
-- Never use this tool unless the user explicitly mentions "worktree"
-
-## Requirements
-
-- Must be in a git repository, OR have WorktreeCreate/WorktreeRemove hooks configured in settings.json
-- Must not already be in a worktree
-
-## Behavior
-
-- In a git repository: creates a new git worktree inside `.claude/worktrees/` with a new branch based on HEAD
-- Outside a git repository: delegates to WorktreeCreate/WorktreeRemove hooks for VCS-agnostic isolation
-- Switches the session's working directory to the new worktree
-- On session exit, the user will be prompted to keep or remove the worktree
-
-## Parameters
-
-- `name` (optional): A name for the worktree. If not provided, a random name is generated.
-</textarea>

package/concepts/it/Tool-ExitPlanMode.md

@@ -1,62 +0,0 @@
-# ExitPlanMode
-
-## Definizione
-
-Esce dalla modalità pianificazione e sottopone il piano all'approvazione dell'utente. Il contenuto del piano viene letto dal file di piano scritto in precedenza.
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `allowedPrompts` | array | No | Lista di descrizioni dei permessi necessari per implementare il piano |
-
-Ogni elemento nell'array `allowedPrompts`:
-
-| Campo | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `tool` | enum | Sì | Lo strumento applicabile, attualmente supporta solo `Bash` |
-| `prompt` | string | Sì | Descrizione semantica dell'operazione (es. "run tests", "install dependencies") |
-
-## Scenari d'uso
-
-**Adatto per:**
-- In modalità pianificazione, il piano è completato e pronto per l'approvazione dell'utente
-- Solo per task di implementazione che richiedono la scrittura di codice
-
-**Non adatto per:**
-- Task puramente di ricerca/esplorazione — non è necessario uscire dalla modalità pianificazione
-- Voler chiedere all'utente "il piano va bene?" — questa è esattamente la funzione di questo strumento, non usare AskUserQuestion per chiederlo
-
-## Note
-
-- Questo strumento non accetta il contenuto del piano come parametro — lo legge dal file di piano scritto in precedenza
-- L'utente vedrà il contenuto del file di piano per l'approvazione
-- Non usare AskUserQuestion per chiedere "il piano va bene?" prima di chiamare questo strumento, sarebbe ridondante
-- Non menzionare il "piano" nelle domande, poiché l'utente non può vedere il contenuto del piano prima di ExitPlanMode
-
-## Testo originale
-
-<textarea readonly>Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.
-
-## How This Tool Works
-- You should have already written your plan to the plan file specified in the plan mode system message
-- This tool does NOT take the plan content as a parameter - it will read the plan from the file you wrote
-- This tool simply signals that you're done planning and ready for the user to review and approve
-- The user will see the contents of your plan file when they review it
-
-## When to Use This Tool
-IMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.
-
-## Before Using This Tool
-Ensure your plan is complete and unambiguous:
-- If you have unresolved questions about requirements or approach, use AskUserQuestion first (in earlier phases)
-- Once your plan is finalized, use THIS tool to request approval
-
-**Important:** Do NOT use AskUserQuestion to ask "Is this plan okay?" or "Should I proceed?" - that's exactly what THIS tool does. ExitPlanMode inherently requests user approval of your plan.
-
-## Examples
-
-1. Initial task: "Search for and understand the implementation of vim mode in the codebase" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.
-2. Initial task: "Help me implement yank mode for vim" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.
-3. Initial task: "Add a new feature to handle user authentication" - If unsure about auth method (OAuth, JWT, etc.), use AskUserQuestion first, then use exit plan mode tool after clarifying the approach.
-</textarea>

package/concepts/it/Tool-Glob.md

@@ -1,39 +0,0 @@
-# Glob
-
-## Definizione
-
-Strumento veloce di corrispondenza per pattern di nomi file, supporta codebase di qualsiasi dimensione. Restituisce i percorsi dei file corrispondenti ordinati per data di modifica.
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `pattern` | string | Sì | Pattern glob (es. `**/*.js`, `src/**/*.ts`) |
-| `path` | string | No | Directory di ricerca, predefinita la directory di lavoro corrente. Non passare "undefined" o "null" |
-
-## Scenari d'uso
-
-**Adatto per:**
-- Cercare file per pattern di nome file
-- Trovare tutti i file di un tipo specifico (es. tutti i file `.tsx`)
-- Localizzare file quando si cerca una definizione di classe specifica (es. `class Foo`)
-- È possibile lanciare più chiamate Glob in parallelo in un singolo messaggio
-
-**Non adatto per:**
-- Cercare contenuto di file — usare Grep
-- Esplorazione aperta che richiede più cicli di ricerca — usare Task (tipo Explore)
-
-## Note
-
-- Supporta la sintassi glob standard: `*` corrisponde a un livello, `**` a più livelli, `{}` per selezione multipla
-- I risultati sono ordinati per data di modifica
-- Più consigliato rispetto al comando `find` di Bash
-
-## Testo originale
-
-<textarea readonly>- Fast file pattern matching tool that works with any codebase size
-- Supports glob patterns like "**/*.js" or "src/**/*.ts"
-- Returns matching file paths sorted by modification time
-- Use this tool when you need to find files by name patterns
-- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
-- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.</textarea>

package/concepts/it/Tool-Grep.md

@@ -1,57 +0,0 @@
-# Grep
-
-## Definizione
-
-Potente strumento di ricerca nel contenuto basato su ripgrep. Supporta espressioni regolari, filtro per tipo di file e diverse modalità di output.
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `pattern` | string | Sì | Pattern di ricerca con espressione regolare |
-| `path` | string | No | Percorso di ricerca (file o directory), predefinita la directory di lavoro corrente |
-| `glob` | string | No | Filtro per nome file (es. `*.js`, `*.{ts,tsx}`) |
-| `type` | string | No | Filtro per tipo di file (es. `js`, `py`, `rust`), più efficiente di glob |
-| `output_mode` | enum | No | Modalità di output: `files_with_matches` (predefinita), `content`, `count` |
-| `-i` | boolean | No | Ricerca senza distinzione maiuscole/minuscole |
-| `-n` | boolean | No | Mostra numeri di riga (solo modalità content), predefinito true |
-| `-A` | number | No | Numero di righe da mostrare dopo la corrispondenza |
-| `-B` | number | No | Numero di righe da mostrare prima della corrispondenza |
-| `-C` / `context` | number | No | Numero di righe da mostrare prima e dopo la corrispondenza |
-| `head_limit` | number | No | Limita il numero di voci nell'output, predefinito 0 (illimitato) |
-| `offset` | number | No | Salta i primi N risultati |
-| `multiline` | boolean | No | Abilita la modalità di corrispondenza multiriga, predefinito false |
-
-## Scenari d'uso
-
-**Adatto per:**
-- Cercare stringhe o pattern specifici nel codebase
-- Trovare dove vengono usate funzioni/variabili
-- Filtrare i risultati di ricerca per tipo di file
-- Contare il numero di corrispondenze
-
-**Non adatto per:**
-- Cercare file per nome — usare Glob
-- Esplorazione aperta che richiede più cicli di ricerca — usare Task (tipo Explore)
-
-## Note
-
-- Usa la sintassi ripgrep (non grep), i caratteri speciali come le parentesi graffe devono essere escapati
-- La modalità `files_with_matches` restituisce solo i percorsi dei file, la più efficiente
-- La modalità `content` restituisce il contenuto delle righe corrispondenti, supporta righe di contesto
-- La corrispondenza multiriga richiede l'impostazione `multiline: true`
-- Usare sempre lo strumento Grep anziché i comandi `grep` o `rg` in Bash
-
-## Testo originale
-
-<textarea readonly>A powerful search tool built on ripgrep
-
-  Usage:
-  - ALWAYS use Grep for search tasks. NEVER invoke `grep` or `rg` as a Bash command. The Grep tool has been optimized for correct permissions and access.
-  - Supports full regex syntax (e.g., "log.*Error", "function\s+\w+")
-  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
-  - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-  - Use Agent tool for open-ended searches requiring multiple rounds
-  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use `interface\{\}` to find `interface{}` in Go code)
-  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like `struct \{[\s\S]*?field`, use `multiline: true`
-</textarea>

package/concepts/it/Tool-NotebookEdit.md

@@ -1,33 +0,0 @@
-# NotebookEdit
-
-## Definizione
-
-Sostituisce, inserisce o elimina celle specifiche in un Jupyter notebook (file .ipynb).
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `notebook_path` | string | Sì | Percorso assoluto del file notebook |
-| `new_source` | string | Sì | Nuovo contenuto della cella |
-| `cell_id` | string | No | ID della cella da modificare. In modalità inserimento, la nuova cella viene inserita dopo questo ID |
-| `cell_type` | enum | No | Tipo di cella: `code` o `markdown`. Obbligatorio in modalità inserimento |
-| `edit_mode` | enum | No | Modalità di modifica: `replace` (predefinita), `insert`, `delete` |
-
-## Scenari d'uso
-
-**Adatto per:**
-- Modificare celle di codice o markdown in un Jupyter notebook
-- Aggiungere nuove celle a un notebook
-- Eliminare celle da un notebook
-
-## Note
-
-- `cell_number` è indicizzato a partire da 0
-- La modalità `insert` inserisce una nuova cella nella posizione specificata
-- La modalità `delete` elimina la cella nella posizione specificata
-- Il percorso deve essere assoluto
-
-## Testo originale
-
-<textarea readonly>Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.</textarea>

package/concepts/it/Tool-Read.md

@@ -1,56 +0,0 @@
-# Read
-
-## Definizione
-
-Legge il contenuto di un file dal file system locale. Supporta file di testo, immagini, PDF e Jupyter notebook.
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `file_path` | string | Sì | Percorso assoluto del file |
-| `offset` | number | No | Numero di riga iniziale (per la lettura segmentata di file grandi) |
-| `limit` | number | No | Numero di righe da leggere (per la lettura segmentata di file grandi) |
-| `pages` | string | No | Intervallo di pagine PDF (es. "1-5", "3", "10-20"), applicabile solo ai PDF |
-
-## Scenari d'uso
-
-**Adatto per:**
-- Leggere file di codice, file di configurazione e altri file di testo
-- Visualizzare file immagine (Claude è un modello multimodale)
-- Leggere documenti PDF
-- Leggere Jupyter notebook (restituisce tutte le celle con i relativi output)
-- Leggere più file in parallelo per ottenere contesto
-
-**Non adatto per:**
-- Leggere directory — usare il comando `ls` di Bash
-- Esplorazione aperta del codebase — usare Task (tipo Explore)
-
-## Note
-
-- Il percorso deve essere assoluto, non relativo
-- Per impostazione predefinita legge le prime 2000 righe del file
-- Le righe che superano i 2000 caratteri vengono troncate
-- L'output usa il formato `cat -n`, con numeri di riga a partire da 1
-- Per PDF grandi (oltre 10 pagine) è necessario specificare il parametro `pages`, massimo 20 pagine per volta
-- La lettura di un file inesistente restituisce un errore (non causa un crash)
-- È possibile chiamare più Read in parallelo in un singolo messaggio
-
-## Testo originale
-
-<textarea readonly>Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-
-Usage:
-- The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- Any lines longer than 2000 characters will be truncated
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
-- This tool can read PDF files (.pdf). For large PDFs (more than 10 pages), you MUST provide the pages parameter to read specific page ranges (e.g., pages: "1-5"). Reading a large PDF without the pages parameter will fail. Maximum 20 pages per request.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
-- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
-- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
-- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.</textarea>

package/concepts/it/Tool-SendMessage.md

@@ -1,41 +0,0 @@
-# SendMessage
-
-## Definizione
-
-Invia messaggi tra agent all'interno di un team. Utilizzato per la comunicazione diretta, il broadcast e i messaggi di protocollo (richieste/risposte di arresto, approvazione piani).
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|-----------|------|--------------|-------------|
-| `to` | string | Sì | Destinatario: nome del membro, o `"*"` per broadcast a tutti |
-| `message` | string / object | Sì | Messaggio di testo o oggetto di protocollo strutturato |
-| `summary` | string | No | Anteprima di 5-10 parole mostrata nell'interfaccia |
-
-## Tipi di messaggio
-
-### Testo semplice
-Messaggi diretti tra membri del team per coordinamento, aggiornamenti di stato e discussioni sui task.
-
-### Richiesta di arresto
-Chiede a un membro di arrestarsi in modo ordinato: `{ type: "shutdown_request", reason: "..." }`
-
-### Risposta di arresto
-Il membro approva o rifiuta l'arresto: `{ type: "shutdown_response", approve: true/false }`
-
-### Risposta di approvazione piano
-Approva o rifiuta il piano di un membro: `{ type: "plan_approval_response", approve: true/false }`
-
-## Broadcast vs. Diretto
-
-- **Diretto** (`to: "nome-membro"`): Invia a un membro specifico — preferito per la maggior parte delle comunicazioni
-- **Broadcast** (`to: "*"`): Invia a tutti i membri — da usare con parsimonia, solo per annunci critici a livello di team
-
-## Strumenti correlati
-
-| Strumento | Scopo |
-|-----------|-------|
-| `TeamCreate` | Creare un nuovo team |
-| `TeamDelete` | Rimuovere il team al completamento |
-| `Agent` | Avviare membri che si uniscono al team |
-| `TaskCreate` / `TaskUpdate` / `TaskList` | Gestire la lista dei task condivisa |

package/concepts/it/Tool-Skill.md

@@ -1,56 +0,0 @@
-# Skill
-
-## Definizione
-
-Esegue una skill (abilità) nella conversazione principale. Le skill sono capacità specializzate che l'utente può invocare tramite slash command (es. `/commit`, `/review-pr`).
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `skill` | string | Sì | Nome della skill (es. "commit", "review-pr", "pdf") |
-| `args` | string | No | Argomenti della skill |
-
-## Scenari d'uso
-
-**Adatto per:**
-- L'utente ha inserito uno slash command nel formato `/<skill-name>`
-- La richiesta dell'utente corrisponde alla funzionalità di una skill registrata
-
-**Non adatto per:**
-- Comandi CLI integrati (es. `/help`, `/clear`)
-- Una skill già in esecuzione
-- Nomi di skill non presenti nella lista delle skill disponibili
-
-## Note
-
-- 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
-
-## Testo originale
-
-<textarea readonly>Execute a skill within the main conversation
-
-When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
-
-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
-
-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>

package/concepts/it/Tool-Task.md

@@ -1,51 +0,0 @@
-# Task
-
-> **Nota:** Nelle versioni più recenti di Claude Code, questo strumento è stato rinominato in **Agent**. Vedere il documento [Tool-Agent](Tool-Agent).
-
-## Definizione
-
-Avvia un sub agent (SubAgent) per gestire autonomamente task complessi multi-step. I sub agent sono sottoprocessi indipendenti, ciascuno con il proprio set di strumenti e contesto dedicati.
-
-## Parametri
-
-| Parametro | Tipo | Obbligatorio | Descrizione |
-|------|------|------|------|
-| `prompt` | string | Sì | Descrizione del task da eseguire per il sub agent |
-| `description` | string | Sì | Breve riepilogo di 3-5 parole |
-| `subagent_type` | string | Sì | Tipo di sub agent, determina il set di strumenti disponibili |
-| `model` | enum | No | Specifica il modello (sonnet / opus / haiku), predefinito ereditato dal padre |
-| `max_turns` | integer | No | Numero massimo di turni agentici |
-| `run_in_background` | boolean | No | Se eseguire in background; i task in background restituiscono il percorso output_file |
-| `resume` | string | No | ID dell'agent da riprendere, continua dall'ultima esecuzione |
-| `isolation` | enum | No | Modalità di isolamento, `worktree` crea un git worktree temporaneo |
-
-## Tipi di sub agent
-
-| Tipo | Scopo | Strumenti disponibili |
-|------|------|----------|
-| `Bash` | Esecuzione comandi, operazioni git | Bash |
-| `general-purpose` | Task multi-step generici | Tutti gli strumenti |
-| `Explore` | Esplorazione rapida del codebase | Tutti gli strumenti tranne Task/Edit/Write/NotebookEdit/ExitPlanMode |
-| `Plan` | Progettazione del piano di implementazione | Tutti gli strumenti tranne Task/Edit/Write/NotebookEdit/ExitPlanMode |
-| `claude-code-guide` | Q&A sulla guida all'uso di Claude Code | Glob, Grep, Read, WebFetch, WebSearch |
-| `statusline-setup` | Configurazione della barra di stato | Read, Edit |
-
-## Scenari d'uso
-
-**Adatto per:**
-- Task complessi che richiedono il completamento autonomo in più step
-- Esplorazione del codebase e ricerca approfondita (usando il tipo Explore)
-- Lavoro parallelo che richiede ambienti isolati
-- Task a lunga esecuzione che devono essere eseguiti in background
-
-**Non adatto per:**
-- Leggere un percorso file specifico — usare direttamente Read o Glob
-- Cercare in 2-3 file noti — usare direttamente Read
-- Cercare una definizione di classe specifica — usare direttamente Glob
-
-## Note
-
-- Al completamento, il sub agent restituisce un singolo messaggio; il suo risultato non è visibile all'utente e deve essere riportato dall'agent principale
-- È possibile lanciare più chiamate Task in parallelo in un singolo messaggio per migliorare l'efficienza
-- I task in background vengono monitorati tramite lo strumento TaskOutput
-- Il tipo Explore è più lento delle chiamate dirette a Glob/Grep, usarlo solo quando la ricerca semplice non è sufficiente

package/concepts/it/Tool-TaskCreate.md

@@ -1,78 +0,0 @@
-# TaskCreate
-
-## Definizione
-
-Crea una voce strutturata nella lista dei task, per tracciare i progressi, organizzare task complessi e mostrare all'utente l'avanzamento del lavoro.
-
-## 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
-
-## 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
-
-<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.
-
-## When to Use This Tool
-
-Use this tool proactively in these scenarios:
-
-- 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
-
-## When NOT to Use This Tool
-
-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
-
-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.
-
-## Task Fields
-
-- **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.
-
-**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`.
-
-## Tips
-
-- 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>