cc-viewer 1.2.1 → 1.2.2

package/concepts/en/Tool-Skill.md

@@ -0,0 +1,35 @@
+# Skill
+
+## Definition
+
+Executes a skill within the main conversation. Skills are specialized capabilities that users can invoke via slash commands (e.g., `/commit`, `/review-pr`).
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `skill` | string | Yes | Skill name (e.g., "commit", "review-pr", "pdf") |
+| `args` | string | No | Skill arguments |
+
+## Use Cases
+
+**Good for:**
+- When the user enters a slash command in the `/<skill-name>` format
+- When the user's request matches the functionality of a registered skill
+
+**Not good for:**
+- Built-in CLI commands (e.g., `/help`, `/clear`)
+- A skill that is already running
+- Skill names not in the available skills list
+
+## Notes
+
+- Once invoked, the skill expands into a full prompt
+- Supports fully qualified names (e.g., `ms-office-suite:pdf`)
+- The available skills list is provided in system-reminder messages
+- When you see a `<command-name>` tag, it means the skill is already loaded — execute it directly rather than calling this tool again
+- Do not mention a skill without actually calling the tool
+
+## Significance in cc-viewer
+
+Skill calls appear in request logs as `tool_use` content blocks. The prompt expanded from the skill affects the system prompt or message content of subsequent requests.

package/concepts/en/Tool-Task.md

@@ -0,0 +1,53 @@
+# Task
+
+## Definition
+
+Launches a SubAgent to autonomously handle complex multi-step tasks. SubAgents are independent subprocesses, each with their own dedicated tool set and context.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `prompt` | string | Yes | Description of the task for the SubAgent to execute |
+| `description` | string | Yes | A 3-5 word short summary |
+| `subagent_type` | string | Yes | SubAgent type, determines the available tool set |
+| `model` | enum | No | Specify model (sonnet / opus / haiku), defaults to inheriting from parent |
+| `max_turns` | integer | No | Maximum number of agentic turns |
+| `run_in_background` | boolean | No | Whether to run in the background; background tasks return an output_file path |
+| `resume` | string | No | Agent ID to resume, continues from the last execution |
+| `isolation` | enum | No | Isolation mode, `worktree` creates a temporary git worktree |
+
+## SubAgent Types
+
+| Type | Purpose | Available Tools |
+|------|---------|-----------------|
+| `Bash` | Command execution, git operations | Bash |
+| `general-purpose` | General multi-step tasks | All tools |
+| `Explore` | Quick codebase exploration | All tools except Task/Edit/Write/NotebookEdit/ExitPlanMode |
+| `Plan` | Design implementation plans | All tools except Task/Edit/Write/NotebookEdit/ExitPlanMode |
+| `claude-code-guide` | Claude Code usage guide Q&A | Glob, Grep, Read, WebFetch, WebSearch |
+| `statusline-setup` | Configure status bar | Read, Edit |
+
+## Use Cases
+
+**Good for:**
+- Complex tasks requiring multi-step autonomous completion
+- Codebase exploration and deep research (using Explore type)
+- Parallel work requiring isolated environments
+- Long-running tasks that need to run in the background
+
+**Not good for:**
+- Reading a specific file path — use Read or Glob directly
+- Searching within 2-3 known files — use Read directly
+- Searching for a specific class definition — use Glob directly
+
+## Notes
+
+- After completion, the SubAgent returns a single message; its results are not visible to the user and need to be relayed by the main agent
+- Multiple Task calls can be issued in parallel within a single message for efficiency
+- Background tasks are checked for progress via the TaskOutput tool
+- The Explore type is slower than directly calling Glob/Grep; only use it when simple searches are insufficient
+
+## Significance in cc-viewer
+
+Task calls produce SubAgent request chains, which appear in the request list as sub-request sequences independent of MainAgent. SubAgent requests typically have streamlined system prompts and fewer tool definitions, forming a clear contrast with MainAgent.

package/concepts/en/Tool-TaskCreate.md

@@ -0,0 +1,38 @@
+# TaskCreate
+
+## Definition
+
+Creates a structured task list entry for tracking progress, organizing complex tasks, and demonstrating work progress to the user.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `subject` | string | Yes | Short task title in imperative form (e.g., "Fix authentication bug") |
+| `description` | string | Yes | Detailed description including context and acceptance criteria |
+| `activeForm` | string | No | Present continuous text displayed when in progress (e.g., "Fixing authentication bug") |
+| `metadata` | object | No | Arbitrary metadata attached to the task |
+
+## Use Cases
+
+**Good for:**
+- Complex multi-step tasks (more than 3 steps)
+- When the user provides multiple to-do items
+- Tracking work in plan mode
+- When the user explicitly requests a todo list
+
+**Not good for:**
+- A single simple task
+- Simple operations with 3 or fewer steps
+- Pure conversation or information queries
+
+## Notes
+
+- All newly created tasks have an initial status of `pending`
+- `subject` uses imperative form ("Run tests"), `activeForm` uses present continuous ("Running tests")
+- After creating a task, use TaskUpdate to set dependencies (blocks/blockedBy)
+- Before creating, call TaskList first to check for duplicate tasks
+
+## Significance in cc-viewer
+
+TaskCreate is an internal task management operation in Claude Code and does not produce independent API requests. However, the model's tool_use block for calling this tool can be seen in Chat Mode.

package/concepts/en/Tool-TaskGet.md

@@ -0,0 +1,35 @@
+# TaskGet
+
+## Definition
+
+Retrieves the full details of a task by its task ID.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | The task ID to retrieve |
+
+## Return Content
+
+- `subject` — Task title
+- `description` — Detailed requirements and context
+- `status` — Status: `pending`, `in_progress`, or `completed`
+- `blocks` — List of tasks blocked by this task
+- `blockedBy` — List of prerequisite tasks blocking this task
+
+## Use Cases
+
+**Good for:**
+- Getting the full description and context of a task before starting work
+- Understanding task dependencies
+- Getting complete requirements after being assigned a task
+
+## Notes
+
+- After retrieving a task, check whether the `blockedBy` list is empty before starting work
+- Use TaskList to view summary information for all tasks
+
+## Significance in cc-viewer
+
+TaskGet is an internal task management operation and does not produce independent API requests.

package/concepts/en/Tool-TaskList.md

@@ -0,0 +1,36 @@
+# TaskList
+
+## Definition
+
+Lists all tasks in the task list to view overall progress and available work.
+
+## Parameters
+
+No parameters.
+
+## Return Content
+
+Summary information for each task:
+- `id` — Task identifier
+- `subject` — Short description
+- `status` — Status: `pending`, `in_progress`, or `completed`
+- `owner` — Owner (agent ID), empty means unassigned
+- `blockedBy` — List of incomplete task IDs blocking this task
+
+## Use Cases
+
+**Good for:**
+- Viewing available tasks (status is pending, no owner, not blocked)
+- Checking overall project progress
+- Finding blocked tasks
+- Finding the next task after completing one
+
+## Notes
+
+- Prefer processing tasks in ID order (lowest ID first), as earlier tasks usually provide context for later ones
+- Tasks with `blockedBy` cannot be claimed until dependencies are resolved
+- Use TaskGet to get full details of a specific task
+
+## Significance in cc-viewer
+
+TaskList is an internal task management operation and does not produce independent API requests.

package/concepts/en/Tool-TaskOutput.md

@@ -0,0 +1,34 @@
+# TaskOutput
+
+## Definition
+
+Gets the output of a running or completed background task. Applicable to background shells, async agents, and remote sessions.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `task_id` | string | Yes | Task ID |
+| `block` | boolean | Yes | Whether to block and wait for task completion, default `true` |
+| `timeout` | number | Yes | Maximum wait time in milliseconds, default 30000, max 600000 |
+
+## Use Cases
+
+**Good for:**
+- Checking the progress of background agents launched via Task (`run_in_background: true`)
+- Getting the execution results of background Bash commands
+- Waiting for async tasks to complete and retrieving output
+
+**Not good for:**
+- Foreground tasks — foreground tasks return results directly, no need for this tool
+
+## Notes
+
+- `block: true` blocks until the task completes or times out
+- `block: false` is for non-blocking checks of the current status
+- Task IDs can be found via the `/tasks` command
+- Applicable to all task types: background shells, async agents, remote sessions
+
+## Significance in cc-viewer
+
+TaskOutput calls do not produce API requests themselves; they are internal task management operations in Claude Code and do not appear in request logs.

package/concepts/en/Tool-TaskStop.md

@@ -0,0 +1,27 @@
+# TaskStop
+
+## Definition
+
+Stops a running background task.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `task_id` | string | No | The background task ID to stop |
+| `shell_id` | string | No | Deprecated, use `task_id` instead |
+
+## Use Cases
+
+**Good for:**
+- Terminating long-running tasks that are no longer needed
+- Canceling erroneously started background tasks
+
+## Notes
+
+- Returns a success or failure status
+- The `shell_id` parameter is deprecated; use `task_id` instead
+
+## Significance in cc-viewer
+
+TaskStop calls do not produce API requests themselves; they are internal task management operations in Claude Code.

package/concepts/en/Tool-TaskUpdate.md

@@ -0,0 +1,49 @@
+# TaskUpdate
+
+## Definition
+
+Updates the status, content, or dependencies of a task in the task list.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | The task ID to update |
+| `status` | enum | No | New status: `pending` / `in_progress` / `completed` / `deleted` |
+| `subject` | string | No | New title |
+| `description` | string | No | New description |
+| `activeForm` | string | No | Present continuous text displayed when in progress |
+| `owner` | string | No | New task owner (agent name) |
+| `metadata` | object | No | Metadata to merge (set to null to delete a key) |
+| `addBlocks` | string[] | No | List of task IDs blocked by this task |
+| `addBlockedBy` | string[] | No | List of prerequisite task IDs blocking this task |
+
+## Status Workflow
+
+```
+pending → in_progress → completed
+```
+
+`deleted` can be entered from any status and permanently removes the task.
+
+## Use Cases
+
+**Good for:**
+- Marking a task as `in_progress` when starting work
+- Marking a task as `completed` when work is done
+- Setting dependencies between tasks
+- Updating task content when requirements change
+
+**Important rules:**
+- Only mark a task as `completed` when it is fully finished
+- Keep the task as `in_progress` when encountering errors or blockers
+- Do not mark as `completed` if tests are failing, implementation is incomplete, or unresolved errors exist
+
+## Notes
+
+- Before updating, retrieve the task's latest status via TaskGet to avoid stale data
+- After completing a task, call TaskList to find the next available task
+
+## Significance in cc-viewer
+
+TaskUpdate is an internal task management operation and does not produce independent API requests.

package/concepts/en/Tool-WebFetch.md

@@ -0,0 +1,36 @@
+# WebFetch
+
+## Definition
+
+Fetches web page content from a specified URL, converts HTML to markdown, and processes the content using an AI model based on the prompt.
+
+## 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 |
+
+## Use Cases
+
+**Good for:**
+- Fetching content from public web pages
+- Consulting online documentation
+- Extracting specific information from web pages
+
+**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
+
+## 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
+
+## Significance in cc-viewer
+
+WebFetch calls appear in request logs as `tool_use` / `tool_result` content block pairs. The `tool_result` contains the AI-processed web content summary.

package/concepts/en/Tool-WebSearch.md

@@ -0,0 +1,32 @@
+# WebSearch
+
+## Definition
+
+Performs search engine queries and returns search results for obtaining up-to-date information.
+
+## 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 |
+
+## Use Cases
+
+**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
+
+## 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
+
+## Significance in cc-viewer
+
+WebSearch calls appear in request logs as `tool_use` / `tool_result` content block pairs. The `tool_result` contains the search results list.

package/concepts/en/Tool-Write.md

@@ -0,0 +1,32 @@
+# Write
+
+## Definition
+
+Writes content to the local filesystem. Overwrites the file if it already exists.
+
+## Parameters
+
+| 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 |
+
+## Use Cases
+
+**Good for:**
+- Creating new files
+- When a complete rewrite of file content is needed
+
+**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
+
+## Notes
+
+- 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
+
+## Significance in cc-viewer
+
+Write calls appear in request logs as `tool_use` content blocks, with `input.content` containing the complete written content.

package/concepts/en/Tool-executeCode.md

@@ -0,0 +1,33 @@
+# executeCode (mcp__ide__executeCode)
+
+## Definition
+
+Executes Python code in the Jupyter kernel of the current notebook file.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `code` | string | Yes | The Python code to execute |
+
+## Use Cases
+
+**Good for:**
+- Executing code in a Jupyter notebook environment
+- Testing code snippets
+- Data analysis and computation
+
+**Not good for:**
+- Code execution outside of Jupyter environments — use Bash instead
+- Modifying files — use Edit or Write instead
+
+## 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
+
+## Significance in cc-viewer
+
+executeCode is an MCP tool that appears in the `tools` array of request logs under the name `mcp__ide__executeCode`. Its invocations and returns follow the standard `tool_use` / `tool_result` pattern. Adding or removing MCP tools causes changes to the tools array, which may trigger cache rebuilds.

package/concepts/en/Tool-getDiagnostics.md

@@ -0,0 +1,32 @@
+# getDiagnostics (mcp__ide__getDiagnostics)
+
+## Definition
+
+Gets language diagnostics from VS Code, including syntax errors, type errors, lint warnings, and more.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `uri` | string | No | File URI. If not provided, gets diagnostics for all files |
+
+## Use Cases
+
+**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
+
+**Not good for:**
+- Running tests — use Bash instead
+- Checking runtime errors — use Bash to execute the code instead
+
+## Notes
+
+- 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
+
+## Significance in cc-viewer
+
+getDiagnostics is an MCP tool that appears in the `tools` array of request logs under the name `mcp__ide__getDiagnostics`. Its invocations and returns follow the standard `tool_use` / `tool_result` pattern. Adding or removing MCP tools causes changes to the tools array, which may trigger cache rebuilds.

package/concepts/en/Tools.md

@@ -0,0 +1,73 @@
+# Claude Code Tools Overview
+
+Claude Code provides a set of built-in tools to the model through the Anthropic API's tool_use mechanism. Each MainAgent request includes the complete JSON Schema definitions of these tools in the `tools` array, and the model invokes them via `tool_use` content blocks in its responses.
+
+Below is a categorized index of all tools.
+
+## Agent System
+
+| Tool | Purpose |
+|------|---------|
+| [Task](Tool-Task.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 |
+| [TaskGet](Tool-TaskGet.md) | Get task details |
+| [TaskUpdate](Tool-TaskUpdate.md) | Update task status, dependencies, etc. |
+| [TaskList](Tool-TaskList.md) | List all tasks |
+
+## File Operations
+
+| Tool | Purpose |
+|------|---------|
+| [Read](Tool-Read.md) | Read file contents (supports text, images, PDF, Jupyter notebook) |
+| [Edit](Tool-Edit.md) | Edit files via exact string replacement |
+| [Write](Tool-Write.md) | Write to or overwrite files |
+| [NotebookEdit](Tool-NotebookEdit.md) | Edit Jupyter notebook cells |
+
+## Search
+
+| Tool | Purpose |
+|------|---------|
+| [Glob](Tool-Glob.md) | Search files by filename pattern matching |
+| [Grep](Tool-Grep.md) | Search file contents based on ripgrep |
+
+## Terminal
+
+| Tool | Purpose |
+|------|---------|
+| [Bash](Tool-Bash.md) | Execute shell commands |
+
+## Web
+
+| Tool | Purpose |
+|------|---------|
+| [WebFetch](Tool-WebFetch.md) | Fetch web page content and process it with AI |
+| [WebSearch](Tool-WebSearch.md) | Search engine queries |
+
+## Planning & Interaction
+
+| Tool | Purpose |
+|------|---------|
+| [EnterPlanMode](Tool-EnterPlanMode.md) | Enter plan mode to design an implementation plan |
+| [ExitPlanMode](Tool-ExitPlanMode.md) | Exit plan mode and submit the plan for user approval |
+| [AskUserQuestion](Tool-AskUserQuestion.md) | Ask the user a question for clarification or decisions |
+
+## Extensions
+
+| Tool | Purpose |
+|------|---------|
+| [Skill](Tool-Skill.md) | Execute a skill (slash command) |
+
+## IDE Integration
+
+| Tool | Purpose |
+|------|---------|
+| [getDiagnostics](Tool-getDiagnostics.md) | Get VS Code language diagnostics |
+| [executeCode](Tool-executeCode.md) | Execute code in a Jupyter kernel |
+
+## Significance in cc-viewer
+
+Tool calls are one of the most important observable data points in Claude Code request logs. The `tools` array in each MainAgent request defines the set of tools available to the model, while the `tool_use` / `tool_result` content blocks in responses record the actual tool invocations and returns. cc-viewer parses this data to reconstruct the complete tool call chain in Chat Mode.
+
+Changes in tool definitions (e.g., tools added/removed due to MCP server connection/disconnection) trigger cache rebuilds. See [CacheRebuild](CacheRebuild.md) for details.

package/concepts/en/TranslateContextPollution.md

@@ -0,0 +1,46 @@
+# Translate API Context Pollution
+
+## Background
+
+CC-Viewer includes a built-in translation feature (`POST /api/translate`) powered by the Anthropic Messages API. In the early implementation, translation requests reused cached authentication credentials from the Claude Code session — including both `x-api-key` and `authorization` headers. This caused a subtle but serious issue: translation results frequently returned irrelevant content.
+
+## Root Cause
+
+### Fundamental Difference Between Two Authentication Methods
+
+The Anthropic API supports two authentication methods:
+
+| Method | Header | Typical Source | Characteristics |
+|--------|--------|----------------|-----------------|
+| API Key | `x-api-key: sk-ant-...` | Environment variable / Console | Stateless, each request is independent |
+| OAuth Token | `authorization: Bearer sessionToken` | Claude Code subscription login | Session-bound, server maintains context association |
+
+The key difference: **API Keys are stateless** — each request is completely independent; while **OAuth session tokens are stateful** — the Anthropic server associates requests using the same token to the same session context.
+
+### Pollution Chain
+
+When Claude Code uses subscription OAuth login, the authentication flow looks like:
+
+```
+Claude Code main conversation ──(authorization: Bearer sessionToken)──→ Anthropic API
+                                                                          ↑
+CC-Viewer translate request ──(authorization: Bearer sessionToken)──→ Anthropic API
+```
+
+Since translation requests reused the same session token, the Anthropic server may associate translation requests with Claude Code's main conversation context. This causes:
+
+1. **Translation results influenced by main conversation context**: The translation request's system prompt is "you are a translator", but the server context still contains Claude Code's conversation history, potentially interfering with the model
+2. **Main conversation disturbed by translation requests**: Translation request content (UI text fragments) may be injected into the main conversation context, causing Claude Code's responses to deviate
+3. **Unpredictable behavior**: Since context pollution is server-side behavior, the client cannot detect or control it
+
+## Lessons Learned
+
+- **OAuth session tokens are not "just another API Key"** — they carry server-side state, reusing them means sharing context
+- **Internal service calls should use independent, stateless authentication** to avoid association with user sessions
+
+## References
+
+- [Anthropic API Authentication Docs](https://docs.anthropic.com/en/api/getting-started) — Official documentation on `x-api-key` and `authorization` headers
+- [Claude Code Authentication](https://support.claude.com/en/articles/12304248-managing-api-key-environment-variables-in-claude-code) — API Key environment variable management
+- [Anthropic Bans Subscription OAuth in Third-Party Apps](https://winbuzzer.com/2026/02/19/anthropic-bans-claude-subscription-oauth-in-third-party-apps-xcxwbn/) — Anthropic's restrictions on OAuth token usage scope
+- [Claude Code Authentication: API Keys, Subscriptions, and SSO](https://developertoolkit.ai/en/claude-code/quick-start/authentication/) — Authentication method comparison

package/concepts/es/BodyDiffJSON.md

@@ -0,0 +1,32 @@
+# Body Diff JSON (Comparación incremental del cuerpo de la solicitud)
+
+## Contexto
+
+El MainAgent de Claude Code utiliza un mecanismo de envío de contexto completo: cada solicitud incluye el historial completo de la conversación, el system prompt, las definiciones de herramientas, etc. Esto significa que a medida que avanza la conversación, el cuerpo de la solicitud se vuelve cada vez más grande, y es difícil identificar rápidamente "qué se agregó en esta ronda" al ver el Body sin procesar.
+
+Body Diff JSON resuelve exactamente este problema: compara automáticamente los cuerpos de dos solicitudes MainAgent consecutivas, extrae la parte incremental y te permite ver de un vistazo el contenido realmente nuevo en esta solicitud.
+
+## Cómo funciona
+
+1. **Identificar solicitudes MainAgent consecutivas**: La solicitud actual debe ser de tipo MainAgent y debe existir una solicitud MainAgent anterior
+2. **Comparación campo por campo**: Recorre todos los campos de nivel superior del cuerpo de la solicitud, omitiendo las propiedades internas con prefijo `_`
+3. **Extracción inteligente de diferencias**:
+   - Campos nuevos: Se muestran directamente
+   - Campos eliminados: No se muestran (generalmente no afectan la comprensión)
+   - Campos modificados: Se muestra el valor actual
+   - Tratamiento especial del array `messages`: Solo se muestran los mensajes nuevos (ya que en una conversación normal se usa el modo de adición, los mensajes previos no cambian)
+4. **Detección de reducción del cuerpo**: Si el cuerpo actual es más pequeño que el anterior, indica un truncamiento de contexto o reinicio de sesión, y se muestra un mensaje informativo en lugar del diff
+
+## Escenarios típicos
+
+En una ronda normal de conversación, el Body Diff JSON generalmente solo contiene:
+- `messages`: 1~2 mensajes nuevos (la entrada del usuario + la respuesta del asistente de la ronda anterior)
+
+Si ves cambios en `system`, `tools`, `model` u otros campos en el diff, significa que hubo un cambio de configuración en esta ronda, lo cual suele ser también la causa de la reconstrucción de caché.
+
+## Cómo usarlo
+
+- El Body Diff JSON se muestra en el panel de detalles de la solicitud MainAgent
+- Haz clic en el título para expandir/contraer
+- Soporta dos modos de visualización: JSON y Text, además de copiar con un clic
+- En **CC-Viewer → Configuración global** (esquina superior izquierda), puedes configurar "Expandir Body Diff JSON por defecto"