cx-viewer 1.0.0

package/concepts/en/Tool-ExitPlanMode.md

@@ -0,0 +1,62 @@
+# ExitPlanMode
+
+## Definition
+
+Exits plan mode and submits the plan for user approval. The plan content is read from a previously written plan file.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `allowedPrompts` | array | No | List of permission descriptions required for the implementation plan |
+
+Each element in the `allowedPrompts` array:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `tool` | enum | Yes | The applicable tool, currently only supports `Bash` |
+| `prompt` | string | Yes | Semantic description of the operation (e.g., "run tests", "install dependencies") |
+
+## Use Cases
+
+**Good for:**
+- The plan is complete in plan mode and ready for user approval
+- Only for implementation tasks that require writing code
+
+**Not good for:**
+- Pure research/exploration tasks — no need to exit plan mode
+- Asking the user "Is the plan okay?" — that is exactly what this tool does, do not use AskUserQuestion for that
+
+## Notes
+
+- This tool does not accept plan content as a parameter — it reads from a previously written plan file
+- The user will see the plan file content for approval
+- Do not use AskUserQuestion to ask "Is the plan okay?" before calling this tool, as that would be redundant
+- Do not mention "the plan" in questions, since the user cannot see the plan content before ExitPlanMode
+
+## Original Text
+
+<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/en/Tool-Glob.md

@@ -0,0 +1,39 @@
+# Glob
+
+## Definition
+
+A fast file pattern matching tool that works with any codebase size. Returns matching file paths sorted by modification time.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `pattern` | string | Yes | Glob pattern (e.g., `**/*.js`, `src/**/*.ts`) |
+| `path` | string | No | Search directory, defaults to the current working directory. Do not pass "undefined" or "null" |
+
+## Use Cases
+
+**Good for:**
+- Finding files by filename pattern
+- Finding all files of a specific type (e.g., all `.tsx` files)
+- Locating files first when searching for a specific class definition (e.g., `class Foo`)
+- Multiple Glob calls can be issued in parallel within a single message
+
+**Not good for:**
+- Searching file contents — use Grep instead
+- Open-ended exploration requiring multiple rounds of searching — use Task (Explore type) instead
+
+## Notes
+
+- Supports standard glob syntax: `*` matches single level, `**` matches multiple levels, `{}` matches alternatives
+- Results are sorted by modification time
+- Preferred over the `find` command in Bash
+
+## Original Text
+
+<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/en/Tool-Grep.md

@@ -0,0 +1,57 @@
+# Grep
+
+## Definition
+
+A powerful content search tool based on ripgrep. Supports regular expressions, file type filtering, and multiple output modes.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `pattern` | string | Yes | Regular expression search pattern |
+| `path` | string | No | Search path (file or directory), defaults to current working directory |
+| `glob` | string | No | Filename filter (e.g., `*.js`, `*.{ts,tsx}`) |
+| `type` | string | No | File type filter (e.g., `js`, `py`, `rust`), more efficient than glob |
+| `output_mode` | enum | No | Output mode: `files_with_matches` (default), `content`, `count` |
+| `-i` | boolean | No | Case-insensitive search |
+| `-n` | boolean | No | Show line numbers (content mode only), default true |
+| `-A` | number | No | Number of lines to show after a match |
+| `-B` | number | No | Number of lines to show before a match |
+| `-C` / `context` | number | No | Number of lines to show before and after a match |
+| `head_limit` | number | No | Limit the number of output entries, default 0 (unlimited) |
+| `offset` | number | No | Skip the first N results |
+| `multiline` | boolean | No | Enable multiline matching mode, default false |
+
+## Use Cases
+
+**Good for:**
+- Searching for specific strings or patterns in the codebase
+- Finding where functions/variables are used
+- Filtering search results by file type
+- Counting the number of matches
+
+**Not good for:**
+- Finding files by filename — use Glob instead
+- Open-ended exploration requiring multiple rounds of searching — use Task (Explore type) instead
+
+## Notes
+
+- Uses ripgrep syntax (not grep); special characters like braces need escaping
+- `files_with_matches` mode returns only file paths, most efficient
+- `content` mode returns matching line content, supports context lines
+- Multiline matching requires setting `multiline: true`
+- Always prefer the Grep tool over `grep` or `rg` commands in Bash
+
+## Original Text
+
+<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/en/Tool-NotebookEdit.md

@@ -0,0 +1,33 @@
+# NotebookEdit
+
+## Definition
+
+Replaces, inserts, or deletes specific cells in a Jupyter notebook (.ipynb file).
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `notebook_path` | string | Yes | Absolute path of the notebook file |
+| `new_source` | string | Yes | New content for the cell |
+| `cell_id` | string | No | ID of the cell to edit. In insert mode, the new cell is inserted after this ID |
+| `cell_type` | enum | No | Cell type: `code` or `markdown`. Required in insert mode |
+| `edit_mode` | enum | No | Edit mode: `replace` (default), `insert`, `delete` |
+
+## Use Cases
+
+**Good for:**
+- Modifying code or markdown cells in a Jupyter notebook
+- Adding new cells to a notebook
+- Deleting cells from a notebook
+
+## Notes
+
+- `cell_number` is 0-indexed
+- `insert` mode inserts a new cell at the specified position
+- `delete` mode deletes the cell at the specified position
+- The path must be an absolute path
+
+## Original Text
+
+<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/en/Tool-Read.md

@@ -0,0 +1,56 @@
+# Read
+
+## Definition
+
+Reads file contents from the local filesystem. Supports text files, images, PDFs, and Jupyter notebooks.
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `file_path` | string | Yes | Absolute path of the file |
+| `offset` | number | No | Starting line number (for reading large files in segments) |
+| `limit` | number | No | Number of lines to read (for reading large files in segments) |
+| `pages` | string | No | PDF page range (e.g., "1-5", "3", "10-20"), only applicable to PDFs |
+
+## Use Cases
+
+**Good for:**
+- Reading code files, configuration files, and other text files
+- Viewing image files (Claude is a multimodal model)
+- Reading PDF documents
+- Reading Jupyter notebooks (returns all cells with outputs)
+- Reading multiple files in parallel to gather context
+
+**Not good for:**
+- Reading directories — use the `ls` command in Bash instead
+- Open-ended codebase exploration — use Task (Explore type) instead
+
+## Notes
+
+- The path must be an absolute path, not a relative path
+- Reads the first 2000 lines of a file by default
+- Lines exceeding 2000 characters will be truncated
+- Output uses `cat -n` format, with line numbers starting at 1
+- Large PDFs (over 10 pages) must specify the `pages` parameter, max 20 pages per call
+- Reading a non-existent file returns an error (does not crash)
+- Multiple Read calls can be issued in parallel within a single message
+
+## Original Text
+
+<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/en/Tool-SendMessage.md

@@ -0,0 +1,41 @@
+# SendMessage
+
+## Definition
+
+Sends messages between agents within a team. Used for direct communication, broadcasting, and protocol messages (shutdown requests/responses, plan approval).
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `to` | string | Yes | Recipient: teammate name, or `"*"` for broadcast to all |
+| `message` | string / object | Yes | Plain text message or structured protocol object |
+| `summary` | string | No | A 5-10 word preview shown in the UI |
+
+## Message Types
+
+### Plain Text
+Direct messages between teammates for coordination, status updates, and task discussions.
+
+### Shutdown Request
+Asks a teammate to gracefully shut down: `{ type: "shutdown_request", reason: "..." }`
+
+### Shutdown Response
+Teammate approves or rejects a shutdown: `{ type: "shutdown_response", approve: true/false }`
+
+### Plan Approval Response
+Approves or rejects a teammate's plan: `{ type: "plan_approval_response", approve: true/false }`
+
+## Broadcast vs Direct
+
+- **Direct** (`to: "teammate-name"`): Send to a specific teammate — preferred for most communication
+- **Broadcast** (`to: "*"`): Send to all teammates — use sparingly, only for critical team-wide announcements
+
+## Related Tools
+
+| Tool | Purpose |
+|------|---------|
+| `TeamCreate` | Create a new team |
+| `TeamDelete` | Remove team when done |
+| `Agent` | Spawn teammates that join the team |
+| `TaskCreate` / `TaskUpdate` / `TaskList` | Manage the shared task list |

package/concepts/en/Tool-Skill.md

@@ -0,0 +1,56 @@
+# 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
+
+## Original Text
+
+<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/en/Tool-Task.md

@@ -0,0 +1,51 @@
+# Task
+
+> **Note:** In newer versions of Claude Code, this tool has been renamed to **Agent**. See the [Tool-Agent](Tool-Agent) document.
+
+## 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

package/concepts/en/Tool-TaskCreate.md

@@ -0,0 +1,78 @@
+# 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
+
+## Original Text
+
+<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>

package/concepts/en/Tool-TaskGet.md

@@ -0,0 +1,56 @@
+# 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
+
+## Original Text
+
+<textarea readonly>Use this tool to retrieve a task by its ID from the task list.
+
+## When to Use This Tool
+
+- 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
+
+## Output
+
+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
+
+## Tips
+
+- After fetching a task, verify its blockedBy list is empty before beginning work.
+- Use TaskList to see all tasks in summary form.
+</textarea>

package/concepts/en/Tool-TaskList.md

@@ -0,0 +1,56 @@
+# 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
+
+## Original Text
+
+<textarea readonly>Use this tool to list all tasks in the task list.
+
+## When to Use This Tool
+
+- 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
+
+## Output
+
+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)
+
+Use TaskGet with a specific task ID to view full details including description and comments.
+</textarea>

package/concepts/en/Tool-TaskOutput.md

@@ -0,0 +1,40 @@
+# 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
+
+## Original Text
+
+<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>

package/concepts/en/Tool-TaskStop.md

@@ -0,0 +1,32 @@
+# 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
+
+## Original Text
+
+<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>