cc-viewer 1.6.182 → 1.6.183

package/concepts/en/Tool-WebFetch.md

@@ -1,55 +1,50 @@
 # WebFetch
 
-## Definition
+Retrieves the contents of a public web page, converts the HTML to Markdown, and runs a small auxiliary model over the result using a natural-language prompt to extract the information you need.
 
-Fetches web page content from a specified URL, converts HTML to markdown, and processes the content using an AI model based on the prompt.
+## When to Use
+
+- Reading a public documentation page, blog post, or RFC referenced in the conversation.
+- Extracting a specific fact, code snippet, or table from a known URL without loading the full page into context.
+- Summarizing release notes or changelogs from an open web resource.
+- Checking a library's public API reference when the source is not in the local repository.
+- Following a link the user pasted into chat to answer a follow-up question.
 
 ## Parameters
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `url` | string (URI) | Yes | The full URL to fetch |
-| `prompt` | string | Yes | Describes what information to extract from the page |
+- `url` (string, required): A fully-formed absolute URL. Plain `http://` is automatically upgraded to `https://`.
+- `prompt` (string, required): The instruction passed to the small extraction model. Describe exactly what to pull out of the page, such as "list all exported functions" or "return the minimum supported Node version".
+
+## Examples
+
+### Example 1: Extract a configuration default
+
+```
+WebFetch(
+  url="https://vitejs.dev/config/server-options.html",
+  prompt="What is the default value of server.port and can it be a string?"
+)
+```
+
+The tool fetches the Vite docs page, converts it to Markdown, and returns a short answer such as "Default is `5173`; accepts a number only."
 
-## Use Cases
+### Example 2: Summarize a changelog section
 
-**Good for:**
-- Fetching content from public web pages
-- Consulting online documentation
-- Extracting specific information from web pages
+```
+WebFetch(
+  url="https://nodejs.org/en/blog/release/v20.11.0",
+  prompt="List the security fixes included in this release as bullet points."
+)
+```
 
-**Not good for:**
-- URLs requiring authentication (Google Docs, Confluence, Jira, GitHub, etc.) — look for a dedicated MCP tool first
-- GitHub URLs — prefer using the `gh` CLI
+Useful when the user asks "what changed in Node 20.11" and the release page is long.
 
 ## Notes
 
-- The URL must be a complete, valid URL
-- HTTP is automatically upgraded to HTTPS
-- Results may be summarized if the content is too large
-- Includes a 15-minute self-cleaning cache
-- When a URL redirects to a different host, the tool returns the redirect URL, and you need to re-request with the new URL
-- If an MCP-provided web fetch tool is available, prefer using that one
-
-## Original Text
-
-<textarea readonly>IMPORTANT: WebFetch WILL FAIL for authenticated or private URLs. Before using this tool, check if the URL points to an authenticated service (e.g. Google Docs, Confluence, Jira, GitHub). If so, you MUST use ToolSearch first to find a specialized tool that provides authenticated access.
-
-- Fetches content from a specified URL and processes it using an AI model
-- Takes a URL and a prompt as input
-- Fetches the URL content, converts HTML to markdown
-- Processes the content with the prompt using a small, fast model
-- Returns the model's response about the content
-- Use this tool when you need to retrieve and analyze web content
-
-Usage notes:
-  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions.
-  - The URL must be a fully-formed valid URL
-  - HTTP URLs will be automatically upgraded to HTTPS
-  - The prompt should describe what information you want to extract from the page
-  - This tool is read-only and does not modify any files
-  - Results may be summarized if the content is very large
-  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
-  - When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.
-  - For GitHub URLs, prefer using the gh CLI via Bash instead (e.g., gh pr view, gh issue view, gh api).
-</textarea>
+- `WebFetch` fails on any URL that requires authentication, cookies, or a VPN. For Google Docs, Confluence, Jira, private GitHub resources, or internal wikis, use a dedicated MCP server that provides authenticated access instead.
+- For anything hosted on GitHub (PRs, issues, file blobs, API responses), prefer the `gh` CLI through `Bash` rather than scraping the web UI. `gh pr view`, `gh issue view`, and `gh api` return structured data and work against private repositories.
+- Results may be summarized when the fetched page is very large. If you need exact text, narrow the `prompt` to ask for a literal extract.
+- A self-cleaning 15-minute cache is applied per URL. Repeated calls to the same page during one session are near-instant but may return slightly stale content. If freshness matters, mention that in the prompt or wait out the cache.
+- If the target host issues a cross-host redirect, the tool returns the new URL in a special response block and does not follow it automatically. Re-invoke `WebFetch` with the redirect target if you still want the content.
+- The prompt is executed by a smaller, faster model than the main assistant. Keep it narrow and concrete; complex multi-step reasoning is better handled by reading the raw Markdown yourself after fetching.
+- Never pass secrets, tokens, or session identifiers embedded in the URL — page contents and query strings reflected in output may be logged by upstream services.

package/concepts/en/Tool-WebSearch.md

@@ -1,58 +1,51 @@
 # WebSearch
 
-## Definition
+Performs a live web search and returns ranked results that the assistant uses to ground its answer in current information beyond the model's training cutoff.
 
-Performs search engine queries and returns search results for obtaining up-to-date information.
+## When to Use
+
+- Answering questions about current events, recent releases, or breaking news.
+- Looking up the latest version of a library, framework, or CLI tool.
+- Finding documentation or blog posts when the exact URL is unknown.
+- Verifying a fact that may have changed since the model was trained.
+- Discovering multiple perspectives on a topic before fetching any single page with `WebFetch`.
 
 ## Parameters
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `query` | string | Yes | Search query (minimum 2 characters) |
-| `allowed_domains` | string[] | No | Only include results from these domains |
-| `blocked_domains` | string[] | No | Exclude results from these domains |
+- `query` (string, required): The search query. Minimum length 2 characters. Include the current year when asking about "latest" or "recent" information so results are fresh.
+- `allowed_domains` (array of strings, optional): Restricts results to only these domains, for example `["nodejs.org", "developer.mozilla.org"]`. Useful when you trust a specific source.
+- `blocked_domains` (array of strings, optional): Excludes results from these domains. Do not pass the same domain to both `allowed_domains` and `blocked_domains`.
+
+## Examples
+
+### Example 1: Version lookup with current year
+
+```
+WebSearch(
+  query="React 19 stable release date 2026",
+  allowed_domains=["react.dev", "github.com"]
+)
+```
+
+Returns official announcements and avoids low-quality aggregator sites.
+
+### Example 2: Exclude noisy sources
 
-## Use Cases
+```
+WebSearch(
+  query="kubernetes ingress-nginx CVE April 2026",
+  blocked_domains=["pinterest.com", "medium.com"]
+)
+```
 
-**Good for:**
-- Getting the latest information beyond the model's knowledge cutoff date
-- Finding current events and recent data
-- Searching for the latest technical documentation
+Keeps results focused on vendor advisories and security trackers.
 
 ## Notes
 
-- Search results are returned in markdown hyperlink format
-- After using this tool, a "Sources:" section must be appended at the end of the response listing the relevant URLs
-- Supports domain filtering (include/exclude)
-- Use the current year in search queries
-- Only available in the US
-
-## Original Text
-
-<textarea readonly>
-- Allows Claude to search the web and use the results to inform responses
-- Provides up-to-date information for current events and recent data
-- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
-- Use this tool for accessing information beyond Claude's knowledge cutoff
-- Searches are performed automatically within a single API call
-
-CRITICAL REQUIREMENT - You MUST follow this:
-  - After answering the user's question, you MUST include a "Sources:" section at the end of your response
-  - In the Sources section, list all relevant URLs from the search results as markdown hyperlinks: [Title](URL)
-  - This is MANDATORY - never skip including sources in your response
-  - Example format:
-
-    [Your answer here]
-
-    Sources:
-    - [Source Title 1](https://example.com/1)
-    - [Source Title 2](https://example.com/2)
-
-Usage notes:
-  - Domain filtering is supported to include or block specific websites
-  - Web search is only available in the US
-
-IMPORTANT - Use the correct year in search queries:
-  - The current month is March 2026. You MUST use this year when searching for recent information, documentation, or current events.
-  - Example: If the user asks for "latest React docs", search for "React documentation" with the current year, NOT last year
-</textarea>
+- When you use `WebSearch` in an answer, you must append a `Sources:` section at the end of your response listing each cited result as a Markdown hyperlink of the form `[Title](URL)`. This is a hard requirement, not optional.
+- `WebSearch` is only available to users in the United States. If the tool is unavailable in your region, fall back to `WebFetch` against a known URL or ask the user to paste relevant content.
+- Each call performs the search in a single round-trip — you cannot stream or paginate. Refine the query if the first result set is off-target.
+- The tool returns snippets and metadata, not full page contents. To read a specific hit in depth, follow up with `WebFetch` using the returned URL.
+- Use `allowed_domains` to enforce authoritative sourcing for security-sensitive questions such as CVEs or compliance, and `blocked_domains` to cut out SEO farms that mirror documentation.
+- Keep queries short and keyword-driven. Natural-language questions work but tend to return conversational answers rather than primary sources.
+- Do not invent URLs based on search intuition — always run the search and cite what the tool actually returned.

package/concepts/en/Tool-Write.md

@@ -1,39 +1,35 @@
 # Write
 
-## Definition
+Creates a new file or fully replaces the contents of an existing one on the local filesystem. Because it replaces everything at the target path, it should be reserved for genuine creation or intentional full rewrites.
 
-Writes content to the local filesystem. Overwrites the file if it already exists.
+## When to Use
 
-## Parameters
+- Creating a brand-new source file, test, or configuration that does not yet exist
+- Generating a fresh fixture, snapshot, or data file from scratch
+- Performing a complete rewrite where an incremental `Edit` would be more complex than starting over
+- Emitting a requested artifact such as a schema, migration, or build script that the user explicitly asked you to produce
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `file_path` | string | Yes | Absolute path of the file (must be an absolute path) |
-| `content` | string | Yes | The content to write |
+## Parameters
 
-## Use Cases
+- `file_path` (string, required): Absolute path of the file to write. Any parent directories must already exist.
+- `content` (string, required): The full text to write to the file. This becomes the entire file body.
 
-**Good for:**
-- Creating new files
-- When a complete rewrite of file content is needed
+## Examples
 
-**Not good for:**
-- Modifying partial content in a file — use Edit instead
-- Should not proactively create documentation files (*.md) or READMEs unless the user explicitly requests it
+### Example 1: Create a new helper module
+Call `Write` with `file_path: "/Users/me/app/src/utils/slugify.ts"` and provide the implementation as `content`. Use this only after verifying that the file does not already exist.
 
-## Notes
+### Example 2: Regenerate a derived artifact
+After the schema source changes, rewrite `/Users/me/app/generated/schema.json` in one `Write` call using the freshly generated JSON as `content`.
 
-- If the target file already exists, it must first be read via Read, otherwise it will fail
-- Overwrites the entire content of existing files
-- Prefer using Edit for existing files; Write is only for creating new files or complete rewrites
+### Example 3: Replace a small fixture file
+For a throwaway test fixture where every line changes, `Write` can be clearer than a sequence of `Edit` calls. Read the file first, confirm the scope, then overwrite.
 
-## Original Text
-
-<textarea readonly>Writes a file to the local filesystem.
+## Notes
 
-Usage:
-- This tool will overwrite the existing file if there is one at the provided path.
-- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
-- Prefer the Edit tool for modifying existing files — it only sends the diff. Only use this tool to create new files or for complete rewrites.
-- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.
-- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.</textarea>
+- Before overwriting an existing file, you must call `Read` on it in the current session. `Write` refuses to clobber unseen content.
+- Prefer `Edit` for any change that touches only part of a file. `Edit` sends just the diff, which is faster, safer, and easier to review.
+- Do not proactively create Markdown documentation, `README.md`, or changelog files unless the user explicitly asks for them.
+- Do not add emoji, marketing copy, or decorative banners unless the user requests that style.
+- Verify the parent directory exists first with a `Bash` `ls` call; `Write` does not create intermediate folders.
+- Supply the content exactly as you want it persisted; there is no templating or post-processing.

package/concepts/en/Tool-executeCode.md

@@ -1,41 +1,47 @@
-# executeCode (mcp__ide__executeCode)
+# executeCode
 
-## Definition
+Executes a snippet of code inside a live kernel or sandbox supplied by an IDE integration (for example the Jupyter kernel bound to the currently open notebook). The tool is only present when Claude Code is running alongside a compatible IDE bridge such as the VS Code extension with a Jupyter kernel selected.
 
-Executes Python code in the Jupyter kernel of the current notebook file.
+## When to Use
+
+- Running a quick computation, data inspection, or plot against the state already loaded in an active Jupyter kernel.
+- Validating a snippet of code before pasting it into a notebook cell.
+- Exploring an in-memory dataframe, variable, or model that exists in the kernel but is not serialized to disk.
+- Producing a chart or numeric result that the user wants rendered inline in the IDE.
+
+Do NOT use for standalone scripts that would be better served by `Bash` running `python script.py`, or for code that needs to persist across a fresh kernel.
 
 ## Parameters
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `code` | string | Yes | The Python code to execute |
+- `code` (string, required): The code to execute in the current kernel. Runs as if pasted into a notebook cell — variables defined persist in the kernel until it is restarted.
+- `language` (string, optional): The language of the snippet when the IDE bridge supports multiple kernels. Most commonly omitted; defaults to the language of the active kernel (typically Python).
+
+## Examples
+
+### Example 1: Inspect an in-memory dataframe
+
+```
+executeCode(
+  code="df.head()\nprint(df.shape)\nprint(df.dtypes)"
+)
+```
+
+Returns the first rows, shape, and column dtypes of a dataframe already loaded in the kernel.
 
-## Use Cases
+### Example 2: Quick numeric check
 
-**Good for:**
-- Executing code in a Jupyter notebook environment
-- Testing code snippets
-- Data analysis and computation
+```
+executeCode(
+  code="import numpy as np\nnp.mean([1, 2, 3, 4, 5])"
+)
+```
 
-**Not good for:**
-- Code execution outside of Jupyter environments — use Bash instead
-- Modifying files — use Edit or Write instead
+Runs a one-off calculation without creating a notebook cell.
 
 ## Notes
 
-- This is an MCP (Model Context Protocol) tool provided by IDE integration
-- Code executes in the current Jupyter kernel, and state persists between calls
-- Unless the user explicitly requests it, avoid declaring variables or modifying kernel state
-- State is lost after a kernel restart
-
-## Original Text
-
-<textarea readonly>Execute python code in the Jupyter kernel for the current notebook file.
-    
-    All code will be executed in the current Jupyter kernel.
-    
-    Avoid declaring variables or modifying the state of the kernel unless the user
-    explicitly asks for it.
-    
-    Any code executed will persist across calls to this tool, unless the kernel
-    has been restarted.</textarea>
+- `executeCode` is an IDE-bridge tool. It is unavailable in plain terminal sessions of Claude Code; it only appears when the session is connected to an IDE that exposes a kernel (for example the VS Code Jupyter extension).
+- State persists in the kernel. Variables defined by one `executeCode` call remain visible to later calls, to notebook cells, and to the user — be mindful of side effects.
+- Long-running or blocking code will block the kernel. Keep snippets short; for multi-minute work, write an actual script and run it via `Bash`.
+- Output (stdout, return values, images) is returned to the session. Very large outputs may be truncated by the IDE bridge.
+- For file edits, prefer `Edit`, `Write`, or `NotebookEdit` — `executeCode` is not a substitute for authoring source files.

package/concepts/en/Tool-getDiagnostics.md

@@ -1,32 +1,44 @@
-# getDiagnostics (mcp__ide__getDiagnostics)
+# getDiagnostics
 
-## Definition
+Retrieves language-server diagnostics (errors, warnings, hints) from the connected IDE for a specific file or for every file the IDE currently has open. Used to verify that code changes compile cleanly before declaring a task done.
 
-Gets language diagnostics from VS Code, including syntax errors, type errors, lint warnings, and more.
+## When to Use
+
+- After an `Edit` or `Write` to confirm the change did not introduce a type error, syntax error, or lint warning.
+- Before ending a task to sweep every open file for unresolved problems.
+- When diagnosing an error the user reports — pulling the exact compiler or type-checker message from the IDE avoids guessing.
+- As a lightweight alternative to running a full build or test command when you only need to check static correctness.
+
+Do NOT rely on `getDiagnostics` as a replacement for the test suite. It reports what the language server sees, not what runs at test or production time.
 
 ## Parameters
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `uri` | string | No | File URI. If not provided, gets diagnostics for all files |
+- `uri` (string, optional): The file URI (typically `file:///absolute/path`) to fetch diagnostics for. When omitted, the tool returns diagnostics for every file the IDE currently has open.
 
-## Use Cases
+## Examples
 
-**Good for:**
-- Checking code for syntax, type, lint, and other semantic issues
-- Verifying whether new errors were introduced after editing code
-- Replacing Bash commands for checking code quality
+### Example 1: Check a single file after editing
 
-**Not good for:**
-- Running tests — use Bash instead
-- Checking runtime errors — use Bash to execute the code instead
+```
+getDiagnostics(
+  uri="file:///Users/sky/project/src/auth.ts"
+)
+```
 
-## Notes
+Returns any TypeScript errors, ESLint warnings, or other language-server messages for `src/auth.ts`.
 
-- This is an MCP (Model Context Protocol) tool provided by IDE integration
-- Only available in VS Code / IDE environments
-- Prefer this tool over Bash commands for checking code issues
+### Example 2: Sweep all open files
 
-## Original Text
+```
+getDiagnostics()
+```
+
+Returns diagnostics across every currently open editor. Useful at the end of a multi-file refactor to ensure nothing regressed elsewhere.
+
+## Notes
 
-<textarea readonly>Get language diagnostics from VS Code</textarea>
+- `getDiagnostics` is an IDE-bridge tool. It is only available when Claude Code is connected to a supporting IDE integration (for example the VS Code extension). In a plain terminal session the tool will not appear.
+- The results reflect whatever language servers the IDE has loaded — TypeScript, Pyright, ESLint, rust-analyzer, etc. Quality and coverage depend on the user's IDE setup, not on Claude Code.
+- Diagnostics are live. After an edit, give the language server a moment to re-analyze before interpreting an empty result as success — re-run if the file was just saved.
+- Severity levels typically include `error`, `warning`, `information`, and `hint`. Focus on `error` first; warnings may be intentional project style.
+- For files not currently open in the IDE, the language server may have no diagnostics to report even if the file contains real issues. Open the file or run the build for authoritative coverage.

package/concepts/en/Tools.md

@@ -8,7 +8,7 @@ Below is a categorized index of all tools.
 
 | Tool | Purpose |
 |------|---------|
-| [Task](Tool-Task.md) | Launch a SubAgent to handle complex multi-step tasks |
+| [Agent](Tool-Agent.md) | Launch a SubAgent to handle complex multi-step tasks |
 | [TaskOutput](Tool-TaskOutput.md) | Get the output of a background task |
 | [TaskStop](Tool-TaskStop.md) | Stop a running background task |
 | [TaskCreate](Tool-TaskCreate.md) | Create a structured task list entry |

package/concepts/es/SubAgent-Search.md

@@ -1,20 +1,52 @@
 # SubAgent: Search
 
-## Definición
+## Propósito
 
-Search es un tipo de sub-agente generado por el agente principal de Claude Code para realizar búsquedas en el código fuente. Ejecuta búsquedas dirigidas de archivos y contenido usando herramientas como Glob, Grep y Read, y luego devuelve los resultados al agente padre.
+El subagente Search es un agente de exploración ligero y de solo lectura. Despáchalo cuando necesites entender un código — encontrar dónde vive algo, aprender cómo encajan los componentes o responder preguntas estructurales — sin modificar ningún archivo. Está optimizado para muchas lecturas pequeñas a lo largo de muchos archivos, devolviendo un resumen conciso en lugar de la salida bruta de búsqueda.
 
-## Comportamiento
+Search no es un asistente de propósito general. No puede editar código, ejecutar builds, hacer commits ni abrir conexiones de red más allá de fetches de solo lectura. Su valor es que puede consumir un gran presupuesto de exploración en paralelo sin consumir el contexto del agente principal, y luego devolver una respuesta compacta.
 
-- Se genera automáticamente cuando el agente principal necesita buscar o explorar el código fuente
-- Se ejecuta en un contexto aislado con acceso de solo lectura
-- Usa Glob para coincidencia de patrones de archivos, Grep para búsqueda de contenido y Read para inspección de archivos
-- Devuelve los resultados de búsqueda al agente padre para su posterior procesamiento
+## Cuándo usar
 
-## Cuando aparece
+- Necesitas responder una pregunta que requiere tres o más búsquedas o lecturas distintas. Ejemplo: "¿Cómo se conecta la autenticación desde la ruta de login hasta el almacén de sesiones?"
+- El objetivo es desconocido — aún no sabes qué archivo, módulo o símbolo mirar.
+- Necesitas una visión estructural general de un área desconocida del repo antes de hacer cambios.
+- Quieres cruzar referencias de múltiples candidatos (por ejemplo, cuál de varios helpers con nombres similares se llama realmente en producción).
+- Necesitas un resumen al estilo de una revisión bibliográfica: "lista cada lugar que importa X y categorízalo por sitio de llamada."
 
-Los sub-agentes Search aparecen típicamente cuando:
+No uses Search cuando:
 
-1. El agente principal necesita encontrar archivos, funciones o patrones de código específicos
-2. El usuario solicita una exploración amplia del código fuente
-3. El agente investiga dependencias, referencias o patrones de uso
+- Ya conoces el archivo y la línea exactos. Llama a `Read` directamente.
+- Un solo `Grep` o `Glob` responderá la pregunta. Ejecútalo directamente; despachar un subagente añade sobrecarga.
+- La tarea requiere editar, ejecutar comandos o cualquier efecto secundario. Search es de solo lectura por diseño.
+- Necesitas la salida verbatim exacta de una llamada de herramienta. Los subagentes resumen; no hacen proxy de resultados brutos.
+
+## Niveles de exhaustividad
+
+Elige el nivel que coincida con lo que está en juego.
+
+- `quick` — unas pocas búsquedas dirigidas, respuesta de mejor esfuerzo. Úsalo cuando necesites un puntero rápido (por ejemplo, "¿dónde está la lógica de parseo de variables de entorno?") y estés cómodo iterando si la respuesta es incompleta.
+- `medium` — el valor por defecto. Varias rondas de búsqueda, comprobación cruzada de candidatos y lectura completa de los archivos más relevantes. Úsalo para preguntas típicas de "ayúdame a entender esta área".
+- `very thorough` — exploración exhaustiva. El subagente perseguirá cada pista plausible, leerá el contexto circundante y verificará dos veces los hallazgos antes de resumir. Úsalo cuando la corrección importe (por ejemplo, revisión de seguridad, planificación de migración) o cuando una respuesta incompleta causaría retrabajo.
+
+Niveles de exhaustividad más altos cuestan más tiempo y tokens dentro del subagente, pero esos tokens se quedan dentro del subagente — solo el resumen final vuelve al agente principal.
+
+## Herramientas disponibles
+
+Search tiene acceso a todas las herramientas de solo lectura que usa el agente principal, y nada más:
+
+- `Read` — para leer archivos específicos, incluyendo rangos parciales.
+- `Grep` — para búsquedas de contenido en el árbol.
+- `Glob` — para localizar archivos por patrón de nombre.
+- `Bash` en modo de solo lectura — para comandos que inspeccionan estado sin mutarlo (por ejemplo `git log`, `git show`, `ls`, `wc`).
+- `WebFetch` y `WebSearch` — para leer documentación externa cuando ese contexto es requerido.
+
+Las herramientas de edición (`Write`, `Edit`, `NotebookEdit`), los comandos de shell que modifican el estado y las herramientas del grafo de tareas (`TaskCreate`, `TaskUpdate`, etc.) no están disponibles deliberadamente.
+
+## Notas
+
+- Dale al subagente Search una pregunta específica, no un tema. "Lista cada llamador de `renderMessage` y anota cuáles pasan un tema personalizado" devuelve una respuesta útil; "cuéntame sobre el renderizado" no.
+- El subagente devuelve un resumen. Si necesitas rutas de archivo exactas, pídelas explícitamente en tu prompt.
+- Varias preguntas independientes se despachan mejor como subagentes Search paralelos en lugar de un prompt largo, para que cada uno pueda enfocarse.
+- Como Search no puede editar, combínalo con un paso de edición de seguimiento en el agente principal una vez que sepas qué cambiar.
+- Trata la salida de Search como evidencia, no como verdad absoluta. Para cualquier cosa crítica, abre los archivos citados tú mismo antes de actuar.